six-degrees 0.4.8 → 0.4.10

package/CHANGELOG.md

@@ -6,6 +6,54 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.10] - 2026-09-29
+
+### Changed
+- **The scan status bar is now a notch.** A small pill hangs from the bottom of the header,
+  centred, on every page. It shows nothing while nothing runs, only a tiny dimmed *Auto scan*
+  while the all-day mode waits, and while a scan runs, what it's doing with a thin progress
+  line. Hover or click to open it: who, today's searches, the latest line, *Details* and
+  *Stop*. Other long jobs show there too, starting with recording the Galaxy's replay.
+
+## [0.4.9] - 2026-09-29
+
+### Added
+- **Conversations, in the Social tab.** Every conversation with one of your connections, from your
+  export and the live messages sync: who it's with (name and tier), when it was last active, who
+  wrote last, unread, how many messages, and *Open on LinkedIn* (the thread when the sync found
+  its link, else their profile). Waiting on you comes first, then S and A tier, then the most
+  recent. Group conversations are shown and marked, and aren't counted in warmth. A search box
+  finds people by name.
+- **Keep my messages on this computer**, a switch that's off unless you turn it on. When it's on,
+  the messages themselves, what other people wrote to you included, are kept in the app's data
+  folder (a file of their own beside the Social tab's), and a conversation opens as a thread,
+  newest at the bottom, a page at a time so a thread of thousands opens as fast as a short one.
+  The search box then finds what was said, too. They're never sent anywhere, and "Save a copy of
+  my network" doesn't carry them (Settings says so). Switching it off asks first, then deletes
+  them; *Forget it* deletes them with everything else.
+- **The live messages sync reads a little more of the list.** Each conversation's link, whether
+  it's a group, and its newest message: who wrote last, which now feeds warmth and Waiting on you
+  where your export is missing or older, and its words, which go to the app only while Keep my
+  messages is on. It still opens no conversation, and its saved samples still keep no words.
+
+### Changed
+- **Auto scan is slower and has its own ceilings.** Sittings of 8 pages, then an hour's rest;
+  searches only from 9:00 to 18:00; never more than 40 searches in 24 hours or 200 in 7 days,
+  however high the daily budget is set (the account restricted on 28 September did 373 in a
+  day with the budget at 500); and two days with no searches after any check from LinkedIn.
+- **The scan status bar sits under the buttons.** On each page it now sits in its own row
+  under the header, pushing the page down instead of covering it. On Network Circle it floats
+  just under the header, measured, so a header that wraps to two rows no longer hides it.
+
+### Fixed
+- **The live messages sync keeps what it finds.** It read your conversations but matched none of
+  them: the pattern for a profile link never matched, and LinkedIn's messaging gives a member
+  link your connections list doesn't have. It now matches each person to your connections by
+  link, or by a name only one connection has (the name isn't kept), and scrolls the list's own
+  panel so more than the first 20 conversations load.
+- **Messaging samples keep no words.** The sync's saved samples of LinkedIn's data (for tuning
+  the reader) now drop every piece of writing and every name before they're saved.
+
 ## [0.4.8] - 2026-09-29
 
 ### Changed

package/lib/galaxy-lab.js

@@ -215,7 +215,12 @@ export function mergeSocial(social) {
   for (const [url, v] of Object.entries(social?.live || {})) {
     const k = keyFor({ profile_url: url });
     const cur = merged.get(k) || { total: 0, recent: 0 };
-    if (v.last && (!cur.last || v.last > cur.last)) cur.last = v.last;
+    // The live sync's word on who wrote last counts when it's the newer news:
+    // no export yet, or the conversation moved on since the export was made.
+    if (v.last && (!cur.last || v.last > cur.last)) {
+      cur.last = v.last;
+      if (typeof v.lastFromThem === 'boolean') cur.lastFromThem = v.lastFromThem;
+    }
     cur.unread = v.unread;
     cur.total = Math.max(cur.total || 0, 1);
     merged.set(k, cur);

package/lib/island.js

@@ -0,0 +1,36 @@
+// The notch (app/components/ScanStatusBar.js): one small pill hanging under the
+// header that shows what the app is doing. The scanner shows there on its own;
+// anything else that runs for a while (a replay being recorded, an import) can
+// show there too, through this list.
+//
+//   const done = showActivity({ id: 'replay', label: 'Recording the replay', detail: '12 s' });
+//   … later: done();
+//
+// An activity is { id, label, detail?, progress? (0–1), tone? ('run' | 'idle' | 'warn') }.
+// Showing the same id again replaces it. The list only changes when something
+// in it does, as useSyncExternalStore needs.
+
+const listeners = new Set();
+let activities = [];
+
+export const activitiesNow = () => activities;
+const EMPTY = [];
+export const noActivities = () => EMPTY;
+
+export function watchActivities(f) {
+  listeners.add(f);
+  return () => listeners.delete(f);
+}
+
+export function showActivity(a) {
+  if (!a?.id) return () => {};
+  activities = [...activities.filter((x) => x.id !== a.id), a];
+  listeners.forEach((f) => f());
+  return () => clearActivity(a.id);
+}
+
+export function clearActivity(id) {
+  if (!activities.some((x) => x.id === id)) return;
+  activities = activities.filter((x) => x.id !== id);
+  listeners.forEach((f) => f());
+}

package/lib/linkedin-export.js

@@ -6,6 +6,10 @@
 //
 //   people     per profile: when you last messaged, who wrote last, how many
 //              messages (1:1 conversations only). Never a message's text.
+//   conversations  per conversation: who's in it, when it was last active, who
+//              wrote last, how many messages. The text itself only when you turn
+//              on Keep my messages, and then in a file of its own
+//              (app/api/social/messages).
 //   chapters   your jobs (Positions.csv) and the connections made in each
 //   posts      your posts (Shares.csv) and the connections that came the week after
 //   invites    requests to and from you (Invitations.csv), when the export has them
@@ -49,14 +53,29 @@ export function exportDate(s) {
 
 const urlKey = (u) => keyFor({ profile_url: u });
 
+/** You, in messages.csv: the sender in the most conversations. */
+function selfOf(rows = []) {
+  const senders = new Map();
+  for (const r of rows) {
+    const from = urlKey(r['sender profile url']);
+    const id = r['conversation id'];
+    if (!id || !from) continue;
+    if (!senders.has(from)) senders.set(from, new Set());
+    senders.get(from).add(id);
+  }
+  let self = null;
+  for (const [who, ids] of senders) if (!self || ids.size > senders.get(self).size) self = who;
+  return self;
+}
+
 /**
  * From messages.csv, per person (by profile): { last, lastFromThem, total, recent }.
  * `self` is you: the sender in the most conversations. Only 1:1 conversations
  * count; group threads say little about one relationship. No text is read.
  */
 export function messageStats(rows = []) {
+  const self = selfOf(rows);
   const convos = new Map();
-  const senders = new Map();
   for (const r of rows) {
     const from = urlKey(r['sender profile url']);
     const id = r['conversation id'];
@@ -69,11 +88,7 @@ export function messageStats(rows = []) {
     c.people.add(from);
     to.forEach((p) => c.people.add(p));
     c.msgs.push({ from, t });
-    if (!senders.has(from)) senders.set(from, new Set());
-    senders.get(from).add(id);
   }
-  let self = null;
-  for (const [who, ids] of senders) if (!self || ids.size > senders.get(self).size) self = who;
   let asOf = 0;
   const people = new Map();
   for (const c of convos.values()) {
@@ -96,6 +111,104 @@ export function messageStats(rows = []) {
   return { self, asOf: asOf || null, people };
 }
 
+/**
+ * Every conversation in messages.csv you're part of, one record each:
+ * { id, title, people, group, messages: [{ t, fromMe, text }] }, messages oldest
+ * first. `people` is everyone but you, by profile key; more than one makes it a
+ * group. You are found the way messageStats finds you. The words (the subject,
+ * when there is one, then the message) are read only with keepText: without it
+ * a message is a date and who sent it, and the title (a group's name) is left
+ * out too.
+ */
+export function buildConversations(rows = [], { keepText = false } = {}) {
+  const self = selfOf(rows);
+  const convos = new Map();
+  for (const r of rows) {
+    const from = urlKey(r['sender profile url']);
+    const id = r['conversation id'];
+    if (!id || !from) continue;
+    const t = exportDate(r.date);
+    if (t == null) continue;
+    if (!convos.has(id)) convos.set(id, { id, title: '', everyone: new Set(), messages: [] });
+    const c = convos.get(id);
+    c.everyone.add(from);
+    String(r['recipient profile urls'] || '').split(/[,;\s]+/).filter(Boolean).forEach((u) => c.everyone.add(urlKey(u)));
+    const m = { t, fromMe: from === self };
+    if (keepText) {
+      m.text = [r.subject, r.content].map((x) => String(x || '').trim()).filter(Boolean).join('\n\n');
+      if (!c.title && r['conversation title']) c.title = String(r['conversation title']).trim();
+    }
+    c.messages.push(m);
+  }
+  const conversations = [];
+  for (const c of convos.values()) {
+    if (!c.everyone.has(self)) continue;
+    const people = [...c.everyone].filter((p) => p && p !== self).sort();
+    if (!people.length) continue;
+    c.messages.sort((a, b) => a.t - b.t);
+    const out = { id: c.id, people, group: people.length > 1, messages: c.messages };
+    if (keepText) out.title = c.title;
+    conversations.push(out);
+  }
+  return { self, conversations };
+}
+
+/** What the Conversations list keeps of one conversation, never any words: { id, people, group, last, lastFromThem, count }. */
+export function conversationSummary(c) {
+  const last = c.messages[c.messages.length - 1];
+  return {
+    id: c.id,
+    people: c.people,
+    group: c.group,
+    last: last ? last.t : null,
+    lastFromThem: last ? !last.fromMe : null,
+    count: c.messages.length,
+  };
+}
+
+/**
+ * The Conversations list: the export's conversations with what the live sync
+ * adds (unread, the thread's link, and a newer last message), plus a
+ * conversation for each person the sync found and the export doesn't have yet
+ * (id `live:<key>`, count unknown).
+ */
+export function conversationList(list = [], live = {}) {
+  const out = (Array.isArray(list) ? list : []).map((c) => ({ ...c, unread: null, threadUrl: null }));
+  const oneToOne = new Map();
+  for (const c of out) {
+    if (c.group || c.people?.length !== 1) continue;
+    const had = oneToOne.get(c.people[0]);
+    if (!had || (c.last || 0) > (had.last || 0)) oneToOne.set(c.people[0], c);
+  }
+  for (const [key, v] of Object.entries(live || {})) {
+    if (!v || typeof v !== 'object') continue;
+    let c = oneToOne.get(key);
+    if (!c) {
+      c = { id: `live:${key}`, people: [key], group: false, last: null, lastFromThem: null, count: null, unread: null, threadUrl: null };
+      out.push(c);
+      oneToOne.set(key, c);
+    }
+    if (v.last && (!c.last || v.last > c.last)) {
+      c.last = v.last;
+      if (typeof v.lastFromThem === 'boolean') c.lastFromThem = v.lastFromThem;
+    }
+    c.unread = Number.isFinite(v.unread) ? v.unread : c.unread;
+    c.threadUrl = v.threadUrl || c.threadUrl;
+  }
+  return out;
+}
+
+/**
+ * The order the Conversations list shows: waiting on you (they wrote last, one
+ * to one) first, then your S and A tier people, then the most recent.
+ * `tierOf(conversation)` gives its best tier.
+ */
+export function sortConversations(list = [], tierOf = () => null) {
+  const waiting = (c) => (!c.group && c.lastFromThem === true ? 0 : 1);
+  const tier = (c) => ({ S: 0, A: 1 }[tierOf(c)] ?? 2);
+  return [...list].sort((a, b) => waiting(a) - waiting(b) || tier(a) - tier(b) || (b.last || 0) - (a.last || 0));
+}
+
 /** Warm (in the last 30 days, or 3+ in 90), cool (within a year), dormant (longer ago), or never. */
 export function warmthOf(stat, asOf) {
   if (!stat || !stat.total) return 'never';
@@ -154,3 +267,60 @@ export function invitationSplit(rows = []) {
   }
   return { incoming, outgoing, total: incoming + outgoing };
 }
+
+const nameKey = (s) => String(s || '').split(',')[0].normalize('NFD').replace(/[̀-ͯ]/g, '')
+  .toLowerCase().replace(/[^a-z0-9 ]+/g, ' ').replace(/\s+/g, ' ').trim();
+
+const THREAD_LINK = /^https:\/\/www\.linkedin\.com\/messaging\/[\w\-/%=.]*$/;
+
+/** A link to a LinkedIn messaging thread, or null: nothing else is ever put behind "Open on LinkedIn". */
+export function threadLink(u) {
+  const v = String(u || '').trim();
+  return THREAD_LINK.test(v) ? v : null;
+}
+
+/** A message the live sync read, as it's kept: { t, fromMe, text }, or null. */
+function previewOf(p) {
+  if (!p || typeof p !== 'object') return null;
+  const t = Number(p.t) || null;
+  const text = typeof p.text === 'string' ? p.text.slice(0, 20000) : null;
+  if (!t && !text) return null;
+  return { t, fromMe: p.fromMe === true, text };
+}
+
+/**
+ * The live messages sync's people, matched to your connections. LinkedIn's
+ * messaging gives a member link (/in/ACoA…) your connections list doesn't have,
+ * so a person is matched by their link when it's the same, otherwise by their
+ * name when exactly one connection has it. Only the match is kept, never the
+ * name. Returns { live: { connectionKey: { last, unread, threadUrl,
+ * lastFromThem, preview } }, unmatched }; the caller decides whether the
+ * preview's words are kept.
+ */
+export function matchLive(incoming = {}, connections = []) {
+  const byUrl = new Map();
+  const byName = new Map();
+  for (const c of connections) {
+    const key = keyFor(c);
+    byUrl.set(key, key);
+    const n = nameKey(c.name);
+    if (n) byName.set(n, byName.has(n) ? null : key);   // null: two people share it
+  }
+  const live = {};
+  let unmatched = 0;
+  for (const [url, v] of Object.entries(incoming || {})) {
+    if (!v || typeof v !== 'object') continue;
+    const key = byUrl.get(keyFor({ profile_url: url })) || byName.get(nameKey(v.name)) || null;
+    if (!key) { unmatched += 1; continue; }
+    const last = Number(v.last) || null;
+    if (live[key] && (live[key].last || 0) >= (last || 0)) continue;
+    live[key] = {
+      last,
+      unread: Number.isFinite(Number(v.unread)) && v.unread !== null ? Number(v.unread) : null,
+      threadUrl: threadLink(v.threadUrl),
+      lastFromThem: typeof v.lastFromThem === 'boolean' ? v.lastFromThem : null,
+      preview: previewOf(v.preview),
+    };
+  }
+  return { live, unmatched };
+}

package/lib/social-store.js

@@ -0,0 +1,73 @@
+// Where the Social tab keeps what it knows, per profile, in the data folder:
+//
+//   social-<profile>.json           numbers and dates (app/api/social): who you
+//                                   messaged, when, who wrote last, the list of
+//                                   conversations. Never any words.
+//   social-messages-<profile>.json  the messages themselves, only while Keep my
+//                                   messages is on (app/api/social/messages).
+//
+// Two files so that turning Keep my messages off, or Forget it, deletes the
+// words by deleting one file, and so the everyday file the Galaxy and the
+// Social tab read stays small however many messages there are. Neither is in
+// "Save a copy of my network": that carries an allow-list of files
+// (lib/data-folder.js TRAVELLING_FILES) and these aren't on it.
+
+import { readFileSync, writeFileSync, renameSync, rmSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { dataDir } from './db-client';
+import { resolveProfile } from './profile';
+
+// The last messages file read, while it's unchanged (readMessages).
+const cache = { file: null, mtimeMs: 0, size: 0, data: null };
+
+/** The Social tab's files for the profile in use, or null before there is one. */
+export function socialFiles() {
+  const me = resolveProfile({ create: false });
+  if (!me?.id || !/^[\w-]+$/.test(String(me.id))) return null;
+  const dir = dataDir();
+  const messages = path.join(dir, `social-messages-${me.id}.json`);
+  return {
+    profileId: me.id,
+    social: path.join(dir, `social-${me.id}.json`),
+    messages,
+    // An import's messages arrive in parts (each request stays under the 10 MB
+    // middleware reads); they gather here and replace `messages` at the end.
+    incoming: `${messages}.incoming`,
+  };
+}
+
+export function readJson(file, fallback = null) {
+  try { return JSON.parse(readFileSync(file, 'utf8')) ?? fallback; } catch { return fallback; }
+}
+
+/** Written whole or not at all: a crash mid-write never leaves half a file. */
+export function writeJsonAtomic(file, value) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(value));
+  renameSync(tmp, file);
+  if (cache.file === file) cache.file = null;
+}
+
+/** The kept messages and their live-sync previews, or empty ones. */
+export function readMessages(file) {
+  // Kept in memory while the file is unchanged: a long history is read once,
+  // not on every page of a thread or every letter typed in the search box.
+  let st;
+  try { st = statSync(file); } catch { return { threads: {}, previews: {} }; }
+  if (cache.file === file && cache.mtimeMs === st.mtimeMs && cache.size === st.size) return cache.data;
+  const raw = readJson(file, {});
+  const data = {
+    threads: raw?.threads && typeof raw.threads === 'object' ? raw.threads : {},
+    previews: raw?.previews && typeof raw.previews === 'object' ? raw.previews : {},
+  };
+  Object.assign(cache, { file, mtimeMs: st.mtimeMs, size: st.size, data });
+  return data;
+}
+
+/** The messages gone: the kept file and any import still arriving. */
+export function deleteMessages(files) {
+  if (!files) return;
+  rmSync(files.messages, { force: true });
+  rmSync(files.incoming, { force: true });
+  cache.file = null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "six-degrees",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "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",