six-degrees 0.2.0 → 0.3.0-beta.1

package/.next/standalone/app/api/data/export/route.js

@@ -0,0 +1,49 @@
+import { mkdtempSync, openSync, rmSync, createReadStream } from 'node:fs';
+import { Readable } from 'node:stream';
+import path from 'node:path';
+import { getDb, dataDir } from '../../../../lib/db-client';
+import { buildExport, exportFileName } from '../../../../lib/data-export';
+import { EXPORT_WORK_PREFIX, sweepLeftovers } from '../../../../lib/data-folder';
+import { SCHEMA_SQL } from '../../../../db/schema';
+import { APP_VERSION } from '../../../../lib/app-version';
+
+// Save a copy of the network to carry to another computer: one .sixdegrees
+// file (lib/data-export.js), sent back as a download. A POST, so it takes a
+// click on the app's own page (the cross-site guard applies), and gated with
+// the other routes that hand over or replace everything (lib/gate.js).
+//
+// It is built in a private folder inside the data folder, never anywhere else,
+// and that folder is gone before the first byte is sent: the open file keeps
+// the bytes readable, so an interrupted download leaves no copy behind.
+
+export async function POST(request) {
+  let body = {};
+  try { body = await request.json(); } catch { /* no options: the defaults */ }
+  const includePhotos = body?.photos !== false;
+
+  const dir = dataDir();
+  sweepLeftovers(dir);
+  const work = mkdtempSync(path.join(dir, EXPORT_WORK_PREFIX));
+  try {
+    const file = path.join(work, 'export.sixdegrees');
+    const made = buildExport(getDb(), {
+      dir, outFile: file, includePhotos, appVersion: APP_VERSION, schemaSql: SCHEMA_SQL,
+    });
+    const fd = openSync(file, 'r');
+    rmSync(work, { recursive: true, force: true });
+    const stream = createReadStream(file, { fd });
+    return new Response(Readable.toWeb(stream), {
+      headers: {
+        'Content-Type': 'application/octet-stream',
+        'Content-Disposition': `attachment; filename="${exportFileName()}"`,
+        'Content-Length': String(made.bytes),
+        'Cache-Control': 'no-store',
+        'X-Six-Degrees-People': String(made.people),
+        'X-Six-Degrees-Photos': String(made.photos),
+      },
+    });
+  } catch (err) {
+    rmSync(work, { recursive: true, force: true });
+    return Response.json({ error: `The copy couldn't be made: ${err.message}` }, { status: 500 });
+  }
+}

package/.next/standalone/app/api/data/import/route.js

@@ -0,0 +1,83 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { getDb, dataDir, applySchema } from '../../../../lib/db-client';
+import { SCHEMA_SQL } from '../../../../db/schema';
+import { APP_VERSION } from '../../../../lib/app-version';
+import { countPeople } from '../../../../lib/data-export';
+import { UPLOAD_WORK_PREFIX, sweepLeftovers } from '../../../../lib/data-folder';
+import { requestRefusal } from '../../../../lib/gate';
+import {
+  ImportError, IMPORT_ROUTE, admitImport, receiveUpload, stageImport, pendingImport, cancelPendingImport,
+} from '../../../../lib/data-import';
+import { scannerJob, runningNow } from '../../../../lib/scan-state';
+
+// Bring in a network from another computer. The body is the .sixdegrees file
+// itself; X-Six-Degrees-Size says how big it is (a body cut short must never
+// pass for a whole one), and X-Six-Degrees-Replace is the number of people the
+// user agreed to replace.
+//
+// middleware.js leaves this route alone: Next would copy the whole upload into
+// memory before middleware could refuse it. So every handler here makes the
+// middleware's checks itself, first (lib/gate.js requestRefusal, the same
+// function), and the upload is written to disk as it arrives (receiveUpload).
+//
+// This only checks the file and stages it (lib/data-import.js). The network is
+// replaced the next time the app starts, after a copy of it is kept. Gated
+// (lib/gate.js): it replaces everything.
+
+function refuse(err) {
+  return Response.json({ error: err.message, ...err.extra }, { status: err.status });
+}
+
+export async function POST(request) {
+  const admitted = admitImport(request, {
+    env: process.env,
+    scanRunning: scannerJob,
+    pending: () => pendingImport(dataDir()),
+    currentPeople: () => countPeople(getDb()),
+  });
+  if (admitted.refused) {
+    const { status, ...body } = admitted.refused;
+    return Response.json(body, { status });
+  }
+  const { declared, currentPeople } = admitted;
+
+  const dir = dataDir();
+  sweepLeftovers(dir);
+  const work = mkdtempSync(path.join(dir, UPLOAD_WORK_PREFIX));
+  try {
+    const upload = path.join(work, 'upload.sixdegrees');
+    await receiveUpload(request.body, upload, { declared });
+    // Asked again: a scan (or Install) or a second import could have started during the upload.
+    const job = scannerJob();
+    if (job) {
+      throw new ImportError(`${runningNow(job)}: it started while the file was arriving. Let it finish, then import again.`, { status: 409 });
+    }
+    if (pendingImport(dir)) {
+      throw new ImportError('Another import is already waiting to finish.', { status: 409 });
+    }
+    const pending = stageImport(upload, {
+      dir, applySchema, schemaSql: SCHEMA_SQL, appVersion: APP_VERSION, replacedPeople: currentPeople,
+    });
+    return Response.json({ ok: true, pending });
+  } catch (err) {
+    rmSync(work, { recursive: true, force: true });
+    if (err instanceof ImportError) return refuse(err);
+    return Response.json({ error: `The file couldn't be checked: ${err.message}` }, { status: 500 });
+  }
+}
+
+/** Throw away an import that is waiting, before it starts. */
+export async function DELETE(request) {
+  const refused = requestRefusal({ method: request.method, pathname: IMPORT_ROUTE, headers: request.headers, env: process.env });
+  if (refused) return Response.json({ error: refused.error }, { status: refused.status });
+
+  const result = cancelPendingImport(dataDir());
+  if (result.reason === 'started') {
+    return Response.json(
+      { error: 'This import has already started, so it can only go forward. Restart Six Degrees to finish it.' },
+      { status: 409 },
+    );
+  }
+  return Response.json({ ok: true, cancelled: result.cancelled });
+}

package/.next/standalone/app/api/data/restart/route.js

@@ -0,0 +1,37 @@
+import { after } from 'next/server';
+import { dataDir } from '../../../../lib/db-client';
+import { pendingImport, restartCodeFrom } from '../../../../lib/data-import';
+import { busyRefusal } from '../../../../lib/scan-state';
+
+// Restart the server so a staged import finishes. Only the Mac app can do this:
+// its shell (desktop/main.mjs) tells the server which exit code means "start
+// me again", and does. Anywhere else the server is the Terminal's own process,
+// and ending it would just stop the app, so the page says how instead.
+//
+// Gated (lib/gate.js): it stops the server.
+
+export async function POST() {
+  const code = restartCodeFrom(process.env);
+  if (!code) {
+    return Response.json(
+      { error: "This copy can't restart itself. Stop it and start it again to finish the import." },
+      { status: 409 },
+    );
+  }
+  if (!pendingImport(dataDir())) {
+    return Response.json({ error: 'No import is waiting, so there is nothing to restart for.' }, { status: 409 });
+  }
+  // The scanner (and Install) runs in its own process group and would outlive
+  // the server. The refusal says which is running.
+  const busy = busyRefusal('Stop it on the Scan page first, then restart.');
+  if (busy) {
+    return Response.json({ error: busy }, { status: 409 });
+  }
+  // After the answer has gone, so the page learns it worked. process.exit and
+  // not a signal: Next turns SIGTERM into exit code 143, which the shell would
+  // report as a crash.
+  after(() => {
+    setTimeout(() => process.exit(code), 150);
+  });
+  return Response.json({ ok: true, restarting: true });
+}

package/.next/standalone/app/api/data/reveal/route.js

@@ -0,0 +1,14 @@
+import path from 'node:path';
+import { dataDir } from '../../../../lib/db-client';
+import { revealFolder } from '../../../../lib/data-folder';
+
+// Show the data folder in Finder (or the Linux file browser). It opens the data
+// folder itself and takes nothing from the request. Gated (lib/gate.js) like
+// every route that starts a process.
+
+export async function POST() {
+  const dir = path.resolve(dataDir());
+  const result = await revealFolder(dir);
+  if (result.ok) return Response.json({ ok: true });
+  return Response.json({ error: `${result.message} The folder is ${dir}` }, { status: 500 });
+}

package/.next/standalone/app/api/data/route.js

@@ -0,0 +1,39 @@
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { getDb, dataDir, dbFile, AUTO_BACKUP_PREFIX } from '../../../lib/db-client';
+import { folderReport } from '../../../lib/data-folder';
+import { countPeople, referencedPhotos } from '../../../lib/data-export';
+import {
+  pendingImport, lastImport, restartCodeFrom, restartAdvice, MAX_IMPORT_BYTES,
+} from '../../../lib/data-import';
+import { projectRoot, isGitCheckout } from '../../../lib/paths';
+import { installKind } from '../../../lib/release';
+
+// Settings → Your data: where the network is kept, what it takes up, and any
+// import waiting to finish. Sizes come from the file system; nothing in the
+// folder is read, and chrome-profile/ is only reported as there or not. A read
+// that changes nothing, so it stays open like every other read. The actions
+// live under /api/data/… and are gated (lib/gate.js).
+
+export async function GET() {
+  try {
+    const db = getDb();
+    const dir = path.resolve(dataDir());
+    // A git checkout is its own kind here, as on the rest of the Settings page.
+    const kind = isGitCheckout() ? 'git' : installKind(process.env, projectRoot());
+    const custom = dir !== path.join(homedir(), '.six-degrees');
+    return Response.json({
+      ...folderReport({ dir, dbFile: path.resolve(dbFile()), autoPrefix: AUTO_BACKUP_PREFIX, inNetwork: referencedPhotos(db) }),
+      people: countPeople(db),
+      platform: process.platform,
+      kind,
+      customDataDir: custom,
+      pending: pendingImport(dir),
+      lastImport: lastImport(db),
+      restart: restartAdvice({ kind, code: restartCodeFrom(process.env), dataDir: custom ? dir : null }),
+      maxImportBytes: MAX_IMPORT_BYTES,
+    });
+  } catch (err) {
+    return Response.json({ error: err.message }, { status: 500 });
+  }
+}

package/.next/standalone/app/api/ingest/route.js

@@ -1,5 +1,5 @@
 import { db as supabase } from '../../../lib/db';
-import { uniqueByProfile, splitAlreadyConnected, toIsoDate } from '../../../lib/ingest';
+import { uniqueByProfile, splitAlreadyConnected, toIsoDate, refreshNotifications } from '../../../lib/ingest';
 import { promoteToFirstDegree } from '../../../lib/promote';
 
 function parseHeadline(h) {
@@ -258,55 +258,23 @@ export async function POST(request) {
       } catch (e) { /* auto-detect is optional */ }
     }
 
-    // Create notifications for new connections on refresh
+    // Notifications for a refresh of your own connections: how many are new,
+    // and each new person the model scored S or A (lib/ingest.js
+    // refreshNotifications). New is what this request inserted (newRecords);
+    // their tiers are the ones the rescore above just stored.
     if (degree === 1 && records.length > 0) {
       try {
-        // Check which are actually new (not already in DB)
-        const urls = records.map(r => r.profile_url).filter(Boolean);
-        const { data: existing } = await supabase
-          .from('linkedin_connections')
-          .select('profile_url')
-          .in('profile_url', urls.slice(0, 100));
-        const existingUrls = new Set((existing || []).map(e => e.profile_url));
-        const brandNew = records.filter(r => !existingUrls.has(r.profile_url));
-
-        if (brandNew.length > 0) {
-          // Summary notification
-          await supabase.from('notifications').insert([{
-            user_id: userId || null,
-            type: 'refresh_summary',
-            title: `${brandNew.length} new connection${brandNew.length > 1 ? 's' : ''} found!`,
-            message: brandNew.slice(0, 3).map(r => r.name).join(', ') + (brandNew.length > 3 ? ` +${brandNew.length - 3} more` : ''),
-            icon: '🔄',
-          }]);
-
-          // Individual notifications for S/A tier new connections
-          const eliteNew = brandNew.filter(r => {
-            const hl = (r.headline || '').toLowerCase();
-            return hl.match(/ceo|chief|founder|president|vp|vice president|director|head of/i)
-              || hl.match(/snap|google|meta|apple|amazon|microsoft|blackrock|stripe|palantir/i);
-          });
-          if (eliteNew.length > 0) {
-            await supabase.from('notifications').insert(
-              eliteNew.slice(0, 5).map(r => ({
-                user_id: userId || null,
-                type: 'new_elite_connection',
-                title: `High-value connection: ${r.name}`,
-                message: r.headline?.substring(0, 60),
-                icon: '👑',
-              }))
-            );
-          }
-        } else {
-          // No new connections found
-          await supabase.from('notifications').insert([{
-            user_id: userId || null,
-            type: 'refresh_summary',
-            title: 'Network up to date',
-            message: `Checked ${records.length} connections — no new additions`,
-            icon: '✓',
-          }]);
+        const tiers = new Map();
+        const added = newRecords.map(r => r.profile_url);
+        for (let i = 0; i < added.length; i += 100) {
+          let q = supabase.from('linkedin_connections').select('profile_url, tier')
+            .in('profile_url', added.slice(i, i + 100)).eq('degree', 1);
+          if (userId) q = q.eq('user_id', userId);
+          const { data } = await q;
+          (data || []).forEach(r => tiers.set(r.profile_url, r.tier));
         }
+        const rows = refreshNotifications({ added: newRecords, checked: records.length, tierOf: (url) => tiers.get(url), userId });
+        await supabase.from('notifications').insert(rows);
       } catch (e) { /* notifications are optional */ }
     }