standout 0.5.30 → 0.5.32

package/dist/browser-session.d.ts

@@ -0,0 +1,3 @@
+import { type BrowserContext } from "playwright-core";
+export declare const NAV_TIMEOUT_MS = 20000;
+export declare function scrapeFromChromeSession<T>(extract: (context: BrowserContext) => Promise<T | null>): Promise<T | null>;

package/dist/browser-session.js

@@ -0,0 +1,227 @@
+import { chromium } from "playwright-core";
+import { existsSync, readdirSync, statSync, mkdtempSync, mkdirSync, copyFileSync, rmSync, readFileSync, } from "fs";
+import { homedir, platform, tmpdir } from "os";
+import { join } from "path";
+import { spawn } from "child_process";
+const DEBUG_PORT_WAIT_MS = 10000;
+export const NAV_TIMEOUT_MS = 20000;
+const TOTAL_TIMEOUT_MS = 40000;
+function wait(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function findChromeExecutable() {
+    const os = platform();
+    const candidates = os === "darwin"
+        ? [
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
+            "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+            "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        ]
+        : os === "linux"
+            ? [
+                "/usr/bin/google-chrome",
+                "/usr/bin/google-chrome-stable",
+                "/usr/bin/chromium",
+                "/usr/bin/chromium-browser",
+                "/snap/bin/chromium",
+            ]
+            : os === "win32"
+                ? [
+                    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+                    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+                ]
+                : [];
+    for (const path of candidates) {
+        if (existsSync(path))
+            return path;
+    }
+    return null;
+}
+function findChromeProfileRoot() {
+    const os = platform();
+    const home = homedir();
+    const candidates = os === "darwin"
+        ? [
+            join(home, "Library", "Application Support", "Google", "Chrome"),
+            join(home, "Library", "Application Support", "Chromium"),
+        ]
+        : os === "linux"
+            ? [
+                join(home, ".config", "google-chrome"),
+                join(home, ".config", "chromium"),
+            ]
+            : os === "win32"
+                ? [join(home, "AppData", "Local", "Google", "Chrome", "User Data")]
+                : [];
+    for (const path of candidates) {
+        if (existsSync(path) && existsSync(join(path, "Local State")))
+            return path;
+    }
+    return null;
+}
+function listProfilesByMtime(profileRoot) {
+    try {
+        return readdirSync(profileRoot)
+            .filter((d) => existsSync(join(profileRoot, d, "Cookies")))
+            .map((d) => ({
+            name: d,
+            mtime: statSync(join(profileRoot, d, "Cookies")).mtimeMs,
+        }))
+            .sort((a, b) => b.mtime - a.mtime)
+            .map((p) => p.name);
+    }
+    catch {
+        return [];
+    }
+}
+function prepareProfileCopy(profileRoot, profileName) {
+    try {
+        const tempRoot = mkdtempSync(join(tmpdir(), "standout-chrome-"));
+        mkdirSync(join(tempRoot, "Default"), { recursive: true });
+        const localState = join(profileRoot, "Local State");
+        if (existsSync(localState)) {
+            copyFileSync(localState, join(tempRoot, "Local State"));
+        }
+        const sourceDir = join(profileRoot, profileName);
+        for (const name of ["Cookies", "Cookies-journal", "Preferences"]) {
+            const src = join(sourceDir, name);
+            if (existsSync(src)) {
+                copyFileSync(src, join(tempRoot, "Default", name));
+            }
+        }
+        return tempRoot;
+    }
+    catch {
+        return null;
+    }
+}
+async function waitForDebugPort(userDataDir, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    const portFile = join(userDataDir, "DevToolsActivePort");
+    while (Date.now() < deadline) {
+        if (existsSync(portFile)) {
+            try {
+                const [port] = readFileSync(portFile, "utf-8").trim().split("\n");
+                if (port && /^\d+$/.test(port))
+                    return parseInt(port, 10);
+            }
+            catch {
+                // keep polling
+            }
+        }
+        await wait(200);
+    }
+    return null;
+}
+async function spawnChrome(executablePath, userDataDir) {
+    const os = platform();
+    const args = [
+        "--headless=new",
+        `--user-data-dir=${userDataDir}`,
+        "--remote-debugging-port=0",
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-sync",
+        "--disable-features=AutofillServerCommunication",
+    ];
+    const cleanupFns = [];
+    if (os === "darwin") {
+        // Use `open -n -a` to force a new Chrome process instance on macOS
+        // (direct binary launch gets intercepted by the singleton running Chrome).
+        const appBundle = executablePath.replace(/\.app\/Contents\/MacOS\/.*$/, ".app");
+        const child = spawn("open", ["-n", "-a", appBundle, "--args", ...args], {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        cleanupFns.push(() => {
+            try {
+                spawn("pkill", ["-f", `user-data-dir=${userDataDir}`]);
+            }
+            catch {
+                // skip
+            }
+        });
+    }
+    else {
+        const child = spawn(executablePath, args, {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        cleanupFns.push(() => {
+            try {
+                if (child.pid)
+                    process.kill(child.pid);
+            }
+            catch {
+                // skip
+            }
+        });
+    }
+    const port = await waitForDebugPort(userDataDir, DEBUG_PORT_WAIT_MS);
+    return {
+        port,
+        cleanup: () => cleanupFns.forEach((fn) => fn()),
+    };
+}
+async function withTimeout(promise, ms) {
+    return Promise.race([
+        promise,
+        new Promise((resolve) => setTimeout(() => resolve(null), ms)),
+    ]);
+}
+async function withProfileContext(executablePath, profileRoot, profileName, extract) {
+    const tempProfile = prepareProfileCopy(profileRoot, profileName);
+    if (!tempProfile)
+        return null;
+    const { port, cleanup } = await spawnChrome(executablePath, tempProfile);
+    let browser = null;
+    try {
+        if (!port)
+            return null;
+        browser = await chromium.connectOverCDP(`http://localhost:${port}`);
+        const contexts = browser.contexts();
+        const context = contexts[0] ?? (await browser.newContext());
+        return await extract(context);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (browser)
+            await browser.close().catch(() => undefined);
+        cleanup();
+        await wait(500);
+        try {
+            rmSync(tempProfile, { recursive: true, force: true });
+        }
+        catch {
+            // skip
+        }
+    }
+}
+// Headless, silent read of the user's logged-in Chrome session. Copies each
+// Chrome profile (newest-cookie first) into a throwaway dir, opens it headless,
+// and hands the browser context to `extract`. Returns the first non-null result;
+// any failure (no Chrome, no session, checkpoint, timeout) resolves to null.
+export async function scrapeFromChromeSession(extract) {
+    const executablePath = findChromeExecutable();
+    if (!executablePath)
+        return null;
+    const profileRoot = findChromeProfileRoot();
+    if (!profileRoot)
+        return null;
+    const profiles = listProfilesByMtime(profileRoot);
+    if (profiles.length === 0)
+        return null;
+    return withTimeout((async () => {
+        for (const profile of profiles) {
+            const result = await withProfileContext(executablePath, profileRoot, profile, extract).catch(() => null);
+            if (result)
+                return result;
+        }
+        return null;
+    })(), TOTAL_TIMEOUT_MS);
+}

package/dist/cli.js

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
 import Anthropic from "@anthropic-ai/sdk";
 import chalk from "chalk";
+import http from "node:http";
 import { createInterface } from "readline";
 import { markWrappedShared, STANDOUT_API_URL } from "./api.js";
+import { capPayload } from "./payload.js";
 import { gatherFullEnrichment, gatherProfileBasics, gatherUsageStats, } from "./gather.js";
 import { ensureHeapHeadroom } from "./heap.js";
 import { startMcpServer } from "./mcp.js";
 import { configureProxyFromEnv } from "./proxy.js";
 import { SYSTEM_PROMPT } from "./prompt.js";
 import { TOOLS, executeTool } from "./tools.js";
+import { aggregateView } from "./wrapped/aggregate.js";
 import { renderWrappedAll } from "./wrapped/render.js";
 import { createWrapped } from "./wrapped-client.js";
 import { openWrapped } from "./wrapped-share.js";
@@ -23,6 +26,114 @@ function profileChatEnabled() {
         return true;
     return process.argv.slice(2).includes("--chat");
 }
+// Local-only mode: compute and render the wrapped entirely on this machine. No
+// profile is uploaded, no wrapped row is created, no leaderboard entry is made,
+// and gathering skips every network call. Enable with --local / --no-upload or
+// STANDOUT_LOCAL=1.
+function localOnlyEnabled() {
+    const env = process.env.STANDOUT_LOCAL;
+    if (env === "1" || env === "true")
+        return true;
+    const args = process.argv.slice(2);
+    return args.includes("--local") || args.includes("--no-upload");
+}
+function printBanner() {
+    console.log("\n  ┌────────────────────────────────┐");
+    console.log("  │  are you really tokenmaxxing?  │");
+    console.log("  │  Powered by Standout (YC P26)  │");
+    console.log("  └────────────────────────────────┘\n");
+}
+// First step of the default flow: an arrow-key menu to pick full (cloud) vs
+// local-only. Non-interactive shells (CI, agents) can't answer, so they keep the
+// full flow — pass --local / STANDOUT_LOCAL=1 to force local without a prompt.
+const MODE_OPTIONS = [
+    {
+        key: "full",
+        title: "Full",
+        tag: " (recommended)",
+        lines: [
+            "Your full AI wrapped: LLM-written cards, your score, and a leaderboard rank.",
+            "Reads your local stats plus your public GitHub / LinkedIn / X.",
+        ],
+    },
+    {
+        key: "local",
+        title: "Local only",
+        tag: " — private & offline",
+        lines: [
+            "Stays entirely on your computer. Nothing uploaded, nothing saved.",
+            "Just your local AI-tool stats — no LLM cards, score, or ranking.",
+        ],
+    },
+];
+function renderModeMenu(selected) {
+    const out = [
+        "",
+        chalk.white("  How do you want to run Standout?"),
+        "",
+    ];
+    MODE_OPTIONS.forEach((opt, i) => {
+        const active = i === selected;
+        const pointer = active ? chalk.hex("#ad5cff")("❯ ") : "  ";
+        const title = active
+            ? chalk.bold.white(opt.title) + chalk.dim(opt.tag)
+            : chalk.dim(opt.title + opt.tag);
+        out.push(`${pointer}${title}`);
+        for (const line of opt.lines)
+            out.push(chalk.dim(`    ${line}`));
+        out.push("");
+    });
+    out.push(chalk.dim("  ↑/↓ to move · enter to select"));
+    return out.join("\n");
+}
+async function chooseMode() {
+    if (!process.stdin.isTTY)
+        return "full";
+    let selected = 0;
+    const draw = () => {
+        const text = renderModeMenu(selected);
+        process.stderr.write(text + "\n");
+        return text.split("\n").length;
+    };
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding("utf8");
+        let lines = draw();
+        const redraw = () => {
+            // Jump back to the menu's first line and clear it before redrawing.
+            process.stderr.write(`\x1b[${lines}A\x1b[0J`);
+            lines = draw();
+        };
+        const cleanup = () => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener("data", onData);
+        };
+        const onData = (data) => {
+            if (data === "\x03") {
+                cleanup();
+                process.stderr.write("\n  Cancelled.\n");
+                process.exit(0);
+            }
+            else if (data === "\r" || data === "\n") {
+                cleanup();
+                process.stderr.write("\n");
+                resolve(MODE_OPTIONS[selected].key);
+            }
+            else if (data === "\x1b[A" || data === "k") {
+                selected = (selected + MODE_OPTIONS.length - 1) % MODE_OPTIONS.length;
+                redraw();
+            }
+            else if (data === "\x1b[B" || data === "j") {
+                selected = (selected + 1) % MODE_OPTIONS.length;
+                redraw();
+            }
+        };
+        stdin.on("data", onData);
+    });
+}
 async function confirmPrivacy() {
     process.stderr.write("\nDiscover your Claude Code, Codex, and Cursor stats, then see how you rank.\n" +
         "You'll see your cards first, then review before submitting.\n\n" +
@@ -125,6 +236,94 @@ async function maybeShareWrapped(wrapped) {
         process.stderr.write(`  (${err instanceof Error ? err.message : err})\n\n`);
     }
 }
+// Fully offline path: gather only local signals and render the wrapped deck in
+// the terminal without ever contacting Standout. Reads only local fields, so the
+// deck looks the same minus the server-computed bits — the LLM-written
+// archetype/zinger (sensible defaults are used) and the leaderboard
+// rank/percentiles (omitted, since those need the server cohort).
+async function renderLocalTerminal(prefetched) {
+    const view = aggregateView({
+        profile: prefetched,
+        computed: {},
+        share_url: "",
+    });
+    await renderWrappedAll(view);
+}
+// Local path: gather on-device, then open the real wrapped UI on localhost. The
+// gathered profile is held only in this process and served from an ephemeral
+// in-memory HTTP server — nothing is written to disk, no DB row, no leaderboard
+// entry. The page renders the card image via a stateless endpoint (also not
+// stored) and shows the share options. `--terminal` forces the fully-offline
+// ASCII deck instead.
+async function runLocal() {
+    const terminalOnly = process.argv.slice(2).includes("--terminal");
+    const stop = startLoadingLine("Putting together your AI highlights");
+    let prefetched;
+    try {
+        prefetched = await gatherFullEnrichment({
+            localOnly: true,
+            verbose: false,
+        });
+    }
+    finally {
+        stop();
+    }
+    // Always page the deck in the terminal first.
+    await renderLocalTerminal(prefetched);
+    if (terminalOnly) {
+        process.stderr.write("\n  Local run complete. To publish your wrapped and see how you rank: npx standout\n\n");
+        return;
+    }
+    // Then open the full wrapped (card image + share options) on localhost.
+    // Trim the bulkiest raw fields so the in-memory body stays well under the
+    // render endpoint's request cap, same as the upload path.
+    const { payload } = capPayload(prefetched);
+    const body = JSON.stringify(payload);
+    const server = http.createServer((req, res) => {
+        // The wrapped page (https) reads this over http://localhost, which browsers
+        // treat as a trustworthy origin. Allow any origin for the simple GET.
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        if (req.url && req.url.startsWith("/profile.json")) {
+            res.setHeader("Content-Type", "application/json");
+            res.end(body);
+            return;
+        }
+        res.statusCode = 404;
+        res.end("not found");
+    });
+    await new Promise((resolve, reject) => {
+        server.on("error", reject);
+        server.listen(0, "127.0.0.1", resolve);
+    });
+    const address = server.address();
+    const port = address && typeof address === "object" ? address.port : null;
+    if (!port) {
+        server.close();
+        process.stderr.write("\n  Couldn't start the local server, so the browser view is unavailable.\n" +
+            "  Your wrapped is shown above. Re-run to try the browser view: npx standout --local\n\n");
+        return;
+    }
+    const url = `${STANDOUT_API_URL}/wrapped/live?port=${port}`;
+    process.stderr.write(`\n  Your wrapped is ready — nothing was uploaded or saved.\n` +
+        `  ${url}\n\n` +
+        `  Opening your browser. Keep this terminal open while you view or share.\n` +
+        `  Press Ctrl+C when you're done.\n\n`);
+    try {
+        await openWrapped(url);
+    }
+    catch {
+        process.stderr.write(`  Couldn't open the browser automatically. Open this link manually:\n  ${url}\n\n`);
+    }
+    // Hold the process open (the in-memory server keeps the data available) until
+    // the user exits; then drop everything.
+    await new Promise((resolve) => {
+        process.on("SIGINT", () => {
+            server.close();
+            process.stderr.write("\n  Closed. Nothing was saved.\n");
+            resolve();
+        });
+    });
+}
 async function runAgent(jobId) {
     // The wrapped render + share now run non-interactively (no TTY required), so
     // the command completes when invoked from a Claude Code Bash call. Only the
@@ -132,10 +331,6 @@ async function runAgent(jobId) {
     if (profileChatEnabled()) {
         ensureInteractive("The interactive profile chat");
     }
-    console.log("\n  ┌────────────────────────────────┐");
-    console.log("  │  are you really tokenmaxxing?  │");
-    console.log("  │  Powered by Standout (YC P26)  │");
-    console.log("  └────────────────────────────────┘\n");
     // Only frame the token as a job in the application flow. Otherwise it may be a
     // leaderboard group (`npx standout stanford`), confirmed after the wrapped runs.
     if (jobId && profileChatEnabled()) {
@@ -340,19 +535,37 @@ async function main() {
     const proxy = configureProxyFromEnv();
     if (proxy)
         process.stderr.write(`  (using proxy ${proxy})\n`);
+    const localOnly = localOnlyEnabled();
     if (args.includes("--gather")) {
-        await confirmPrivacy();
-        const data = await gatherFullEnrichment();
+        // Local-only gather skips the upload-consent gate (nothing leaves the box).
+        if (!localOnly)
+            await confirmPrivacy();
+        const data = await gatherFullEnrichment({ localOnly });
         process.stdout.write(JSON.stringify(data, null, 2));
+        return;
     }
-    else if (args.includes("--mcp")) {
+    if (args.includes("--mcp")) {
         await startMcpServer();
+        return;
+    }
+    const jobId = args.find((a) => !a.startsWith("-"));
+    printBanner();
+    // Pick the mode. An explicit --local/--no-upload/STANDOUT_LOCAL forces local;
+    // a group/job arg (`npx standout stanford`) is an explicit full-flow intent; a
+    // bare `npx standout` asks the user as the first step.
+    let mode;
+    if (localOnly)
+        mode = "local";
+    else if (jobId)
+        mode = "full";
+    else
+        mode = await chooseMode();
+    if (mode === "local") {
+        await runLocal();
     }
     else {
-        const jobId = args.find((a) => !a.startsWith("-"));
-        if (jobId) {
+        if (jobId)
             process.env.STANDOUT_JOB_ID = jobId;
-        }
         await runAgent(jobId);
     }
 }

package/dist/gather.d.ts

@@ -25,7 +25,7 @@ export interface GatheredProfile {
     };
     linkedin: {
         url: string | null;
-        url_resolution_source: "email" | "ai_search" | null;
+        url_resolution_source: "email" | "ai_search" | "chrome_session" | null;
         profile: Record<string, unknown> | null;
         company_enrichments: Record<string, Record<string, unknown>>;
     };
@@ -72,6 +72,7 @@ export interface FullEnrichmentOptions {
     aiUsage?: AiUsage;
     profileBasics?: ProfileBasics;
     verbose?: boolean;
+    localOnly?: boolean;
 }
 export declare function emptyGatheredProfile(readiness?: GatherReadiness): GatheredProfile;
 export declare function gatherUsageStats(): Promise<Pick<GatheredProfile, "ai_usage" | "readiness">>;

package/dist/gather.js

@@ -6,6 +6,8 @@ import { STANDOUT_API_URL } from "./api.js";
 import { gatherAiUsage } from "./ai-usage.js";
 import { gatherDevEnvironment } from "./dev-env.js";
 import { scrapeTwitterHandle } from "./twitter-scrape.js";
+import { scrapeLinkedinUrl } from "./linkedin-scrape.js";
+import { resolveDisplayName } from "./identity.js";
 import { redactSecrets } from "./redact.js";
 export function emptyGatheredProfile(readiness = {
     usage_stats_status: "unavailable",
@@ -443,6 +445,7 @@ function trimNpmPackage(p) {
     };
 }
 export async function gather(options = {}) {
+    const localOnly = options.localOnly === true;
     const profileBasics = options.profileBasics?.readiness.profile_basics_status === "ready"
         ? options.profileBasics
         : undefined;
@@ -466,24 +469,32 @@ export async function gather(options = {}) {
                 remoteCandidates.push(match[1]);
             }
         }
-        // Resolve to a USER (not an Organization) profile
-        for (const candidate of remoteCandidates) {
-            const profile = (await fetchGitHub(`https://api.github.com/users/${sanitize(candidate)}`));
-            if (profile?.type === "User" && profile.login) {
-                githubUsername = profile.login;
-                break;
+        if (localOnly) {
+            // No network to verify User vs Org — take the first remote candidate as a
+            // best-effort handle. Only used to label identity; the deck falls back to
+            // the git name regardless.
+            githubUsername = remoteCandidates[0] ?? null;
+        }
+        else {
+            // Resolve to a USER (not an Organization) profile
+            for (const candidate of remoteCandidates) {
+                const profile = (await fetchGitHub(`https://api.github.com/users/${sanitize(candidate)}`));
+                if (profile?.type === "User" && profile.login) {
+                    githubUsername = profile.login;
+                    break;
+                }
             }
         }
     }
     // Fallback: search GitHub by email (public profile email match)
-    if (!githubUsername && email) {
+    if (!githubUsername && email && !localOnly) {
         const searchResult = (await fetchGitHub(`https://api.github.com/search/users?q=${encodeURIComponent(email)}+in:email`));
         if (searchResult?.items?.[0]) {
             githubUsername = searchResult.items[0].login;
         }
     }
     // Fallback: search commits by author-email (catches users with private email)
-    if (!githubUsername && email) {
+    if (!githubUsername && email && !localOnly) {
         const commitSearch = (await fetchGitHub(`https://api.github.com/search/commits?q=author-email:${encodeURIComponent(email)}`));
         const login = commitSearch?.items?.[0]?.author?.login;
         if (login)
@@ -495,7 +506,7 @@ export async function gather(options = {}) {
     gatherLog(options, "Gathering GitHub data...\n");
     const canUseCachedGithubBasics = Boolean(profileBasics?.identity.github_username) &&
         profileBasics?.identity.github_username === githubUsername;
-    const [ghProfile, ghRepos, ghStarred, ghFollowing, ghEvents, ghPrs, ghContrib, ghNpm,] = safeUsername
+    const [ghProfile, ghRepos, ghStarred, ghFollowing, ghEvents, ghPrs, ghContrib, ghNpm,] = safeUsername && !localOnly
         ? await Promise.all([
             canUseCachedGithubBasics
                 ? Promise.resolve(profileBasics?.github.profile ?? null)
@@ -518,7 +529,7 @@ export async function gather(options = {}) {
     const repoContents = {};
     const readmes = {};
     const commitMessages = {};
-    if (safeUsername) {
+    if (safeUsername && !localOnly) {
         const contentPromises = topRepos.map(async (repo) => {
             const repoName = repo.name;
             const contents = (await fetchGitHub(`https://api.github.com/repos/${safeUsername}/${repoName}/contents`));
@@ -553,7 +564,7 @@ export async function gather(options = {}) {
     }
     // Phase 2c: AI tool usage + dev environment (run in background during LinkedIn)
     gatherLog(options, "Scanning AI tool usage and dev environment...\n");
-    const githubEnrichPromise = safeUsername
+    const githubEnrichPromise = safeUsername && !localOnly
         ? enrichApi("github", safeUsername).catch(() => null)
         : Promise.resolve(null);
     const aiUsagePromise = options.aiUsage
@@ -581,7 +592,7 @@ export async function gather(options = {}) {
     let linkedinResolutionSource = null;
     let linkedinProfile = null;
     const companyEnrichments = {};
-    if (safeEmail) {
+    if (safeEmail && !localOnly) {
         const emailResult = await enrichApi("email_to_linkedin", email);
         if (emailResult && typeof emailResult === "object") {
             linkedinUrl =
@@ -592,7 +603,7 @@ export async function gather(options = {}) {
         }
     }
     // Fallback: name + signals via AI web search when email lookup comes up empty
-    if (!linkedinUrl && ghProfile && name) {
+    if (!linkedinUrl && ghProfile && name && !localOnly) {
         gatherLog(options, "Resolving LinkedIn via name + signals...\n");
         const profile = ghProfile;
         const signals = [];
@@ -627,6 +638,24 @@ export async function gather(options = {}) {
             linkedinResolutionSource = "ai_search";
         }
     }
+    // Fallback: read a logged-in LinkedIn session from the local Chrome profile
+    // (headless, silent). Same technique as the X handle scrape — the only anchor
+    // for users with no git email/name and no GitHub remote. Reads the local
+    // browser but resolves a URL the enrich proxy would then look up, so it's
+    // skipped in local-only mode too.
+    if (!linkedinUrl && !localOnly) {
+        gatherLog(options, "Checking for a LinkedIn session in Chrome...\n");
+        try {
+            const scraped = await scrapeLinkedinUrl();
+            if (scraped) {
+                linkedinUrl = scraped;
+                linkedinResolutionSource = "chrome_session";
+            }
+        }
+        catch {
+            // silent
+        }
+    }
     if (linkedinUrl) {
         linkedinProfile = await enrichApi("linkedin_profile", linkedinUrl);
         // Company enrichment
@@ -660,7 +689,7 @@ export async function gather(options = {}) {
         }
     }
     // Fallback: scrape the user's logged-in Chrome session for an X handle.
-    if (!twitterHandle) {
+    if (!twitterHandle && !localOnly) {
         gatherLog(options, "Checking for an X/Twitter session in Chrome...\n");
         try {
             const scraped = await scrapeTwitterHandle();
@@ -673,7 +702,7 @@ export async function gather(options = {}) {
     }
     const safeTwitter = twitterHandle ? sanitize(twitterHandle) : null;
     let twitterProfile = null;
-    if (safeTwitter) {
+    if (safeTwitter && !localOnly) {
         twitterProfile = await enrichApi("twitter", safeTwitter);
     }
     const twitterUrl = safeTwitter ? `https://x.com/${safeTwitter}` : null;
@@ -821,14 +850,22 @@ export async function gather(options = {}) {
         githubEnrichPromise,
     ]);
     gatherLog(options, "Done gathering.\n");
+    const resolvedName = resolveDisplayName({
+        gitName: name,
+        githubName: ghProfile?.name,
+        linkedinProfile: linkedinProfile,
+        githubUsername,
+        twitterHandle,
+    });
     return {
         readiness: {
             usage_stats_status: hasAnyUsage(aiUsage) ? "ready" : "unavailable",
             profile_basics_status: "ready",
-            enrichment_status: "ready",
+            // Local-only mode performs no network enrichment.
+            enrichment_status: localOnly ? "unavailable" : "ready",
         },
         identity: {
-            name: name || null,
+            name: resolvedName,
             email: email || null,
             github_username: githubUsername,
             twitter_username: twitterHandle,

package/dist/identity.d.ts

@@ -0,0 +1,8 @@
+export declare function linkedinFullName(profile: Record<string, unknown> | null | undefined): string | null;
+export declare function resolveDisplayName(opts: {
+    gitName: string | null | undefined;
+    githubName: unknown;
+    linkedinProfile: Record<string, unknown> | null | undefined;
+    githubUsername: string | null | undefined;
+    twitterHandle: string | null | undefined;
+}): string | null;

package/dist/identity.js

@@ -0,0 +1,29 @@
+function cleanName(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+// LinkedIn enrichment exposes the display name as `full_name`, falling back to
+// first/last when only those are present.
+export function linkedinFullName(profile) {
+    if (!profile)
+        return null;
+    const full = cleanName(profile.full_name);
+    if (full)
+        return full;
+    const joined = [cleanName(profile.first_name), cleanName(profile.last_name)]
+        .filter(Boolean)
+        .join(" ")
+        .trim();
+    return joined || null;
+}
+// Identity name fallback chain. The self-set git name stays primary; when it's
+// missing we fall back to real names (GitHub, then LinkedIn) and finally to
+// handles (GitHub, then Twitter) so a wrapped is never anonymous when any
+// identity signal exists.
+export function resolveDisplayName(opts) {
+    return (cleanName(opts.gitName) ??
+        cleanName(opts.githubName) ??
+        linkedinFullName(opts.linkedinProfile) ??
+        cleanName(opts.githubUsername) ??
+        cleanName(opts.twitterHandle) ??
+        null);
+}

package/dist/linkedin-scrape.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeLinkedinUrl(raw: string): string | null;
+export declare function scrapeLinkedinUrl(): Promise<string | null>;

package/dist/linkedin-scrape.js

@@ -0,0 +1,56 @@
+import { NAV_TIMEOUT_MS, scrapeFromChromeSession } from "./browser-session.js";
+// LinkedIn bounces unauthenticated / new-device sessions to one of these.
+const BLOCKED_RE = /\/(login|uas\/login|checkpoint|authwall)/i;
+// Reduce any LinkedIn profile URL to the canonical vanity form, or null if it
+// isn't a real member profile (e.g. the `/in/me` self-redirect target itself).
+export function normalizeLinkedinUrl(raw) {
+    try {
+        const url = new URL(raw);
+        if (!/(^|\.)linkedin\.com$/i.test(url.hostname))
+            return null;
+        const match = url.pathname.match(/\/in\/([^/]+)/i);
+        const vanity = match?.[1] ? decodeURIComponent(match[1]).trim() : null;
+        if (!vanity || vanity.toLowerCase() === "me")
+            return null;
+        return `https://www.linkedin.com/in/${vanity}/`;
+    }
+    catch {
+        return null;
+    }
+}
+async function extractLinkedinUrl(context) {
+    const cookies = await context.cookies(["https://www.linkedin.com"]);
+    if (!cookies.find((c) => c.name === "li_at"))
+        return null;
+    const page = await context.newPage();
+    try {
+        // `/in/me/` redirects to the logged-in member's own vanity profile.
+        await page.goto("https://www.linkedin.com/in/me/", {
+            waitUntil: "domcontentloaded",
+            timeout: NAV_TIMEOUT_MS,
+        });
+        if (BLOCKED_RE.test(page.url()))
+            return null;
+        const fromRedirect = normalizeLinkedinUrl(page.url());
+        if (fromRedirect)
+            return fromRedirect;
+        // Backup signal if the redirect didn't land on a vanity URL.
+        try {
+            const canonical = page.locator('link[rel="canonical"]').first();
+            await canonical.waitFor({ timeout: 3000 });
+            const href = await canonical.getAttribute("href");
+            if (href)
+                return normalizeLinkedinUrl(href);
+        }
+        catch {
+            // skip
+        }
+        return null;
+    }
+    finally {
+        await page.close().catch(() => undefined);
+    }
+}
+export async function scrapeLinkedinUrl() {
+    return scrapeFromChromeSession(extractLinkedinUrl);
+}

package/dist/twitter-scrape.js

@@ -1,267 +1,48 @@
-import { chromium } from "playwright-core";
-import { existsSync, readdirSync, statSync, mkdtempSync, mkdirSync, copyFileSync, rmSync, readFileSync, } from "fs";
-import { homedir, platform, tmpdir } from "os";
-import { join } from "path";
-import { spawn } from "child_process";
-const DEBUG_PORT_WAIT_MS = 10000;
-const NAV_TIMEOUT_MS = 20000;
-const TOTAL_TIMEOUT_MS = 40000;
-function wait(ms) {
-    return new Promise((r) => setTimeout(r, ms));
-}
-function findChromeExecutable() {
-    const os = platform();
-    const candidates = os === "darwin"
-        ? [
-            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-            "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
-            "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
-            "/Applications/Chromium.app/Contents/MacOS/Chromium",
-        ]
-        : os === "linux"
-            ? [
-                "/usr/bin/google-chrome",
-                "/usr/bin/google-chrome-stable",
-                "/usr/bin/chromium",
-                "/usr/bin/chromium-browser",
-                "/snap/bin/chromium",
-            ]
-            : os === "win32"
-                ? [
-                    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
-                    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
-                ]
-                : [];
-    for (const path of candidates) {
-        if (existsSync(path))
-            return path;
-    }
-    return null;
-}
-function findChromeProfileRoot() {
-    const os = platform();
-    const home = homedir();
-    const candidates = os === "darwin"
-        ? [
-            join(home, "Library", "Application Support", "Google", "Chrome"),
-            join(home, "Library", "Application Support", "Chromium"),
-        ]
-        : os === "linux"
-            ? [
-                join(home, ".config", "google-chrome"),
-                join(home, ".config", "chromium"),
-            ]
-            : os === "win32"
-                ? [join(home, "AppData", "Local", "Google", "Chrome", "User Data")]
-                : [];
-    for (const path of candidates) {
-        if (existsSync(path) && existsSync(join(path, "Local State")))
-            return path;
-    }
-    return null;
-}
-function listProfilesByMtime(profileRoot) {
-    try {
-        return readdirSync(profileRoot)
-            .filter((d) => existsSync(join(profileRoot, d, "Cookies")))
-            .map((d) => ({
-            name: d,
-            mtime: statSync(join(profileRoot, d, "Cookies")).mtimeMs,
-        }))
-            .sort((a, b) => b.mtime - a.mtime)
-            .map((p) => p.name);
-    }
-    catch {
-        return [];
-    }
-}
-function prepareProfileCopy(profileRoot, profileName) {
-    try {
-        const tempRoot = mkdtempSync(join(tmpdir(), "standout-chrome-"));
-        mkdirSync(join(tempRoot, "Default"), { recursive: true });
-        const localState = join(profileRoot, "Local State");
-        if (existsSync(localState)) {
-            copyFileSync(localState, join(tempRoot, "Local State"));
-        }
-        const sourceDir = join(profileRoot, profileName);
-        for (const name of ["Cookies", "Cookies-journal", "Preferences"]) {
-            const src = join(sourceDir, name);
-            if (existsSync(src)) {
-                copyFileSync(src, join(tempRoot, "Default", name));
-            }
-        }
-        return tempRoot;
-    }
-    catch {
-        return null;
-    }
-}
-async function waitForDebugPort(userDataDir, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    const portFile = join(userDataDir, "DevToolsActivePort");
-    while (Date.now() < deadline) {
-        if (existsSync(portFile)) {
-            try {
-                const [port] = readFileSync(portFile, "utf-8").trim().split("\n");
-                if (port && /^\d+$/.test(port))
-                    return parseInt(port, 10);
-            }
-            catch {
-                // keep polling
-            }
-        }
-        await wait(200);
-    }
-    return null;
-}
-async function spawnChrome(executablePath, userDataDir) {
-    const os = platform();
-    const args = [
-        "--headless=new",
-        `--user-data-dir=${userDataDir}`,
-        "--remote-debugging-port=0",
-        "--no-first-run",
-        "--no-default-browser-check",
-        "--disable-sync",
-        "--disable-features=AutofillServerCommunication",
-    ];
-    const cleanupFns = [];
-    if (os === "darwin") {
-        // Use `open -n -a` to force a new Chrome process instance on macOS
-        // (direct binary launch gets intercepted by the singleton running Chrome).
-        const appBundle = executablePath.replace(/\.app\/Contents\/MacOS\/.*$/, ".app");
-        const child = spawn("open", ["-n", "-a", appBundle, "--args", ...args], {
-            detached: true,
-            stdio: "ignore",
-        });
-        child.unref();
-        cleanupFns.push(() => {
-            try {
-                spawn("pkill", ["-f", `user-data-dir=${userDataDir}`]);
-            }
-            catch {
-                // skip
-            }
-        });
-    }
-    else {
-        const child = spawn(executablePath, args, {
-            detached: true,
-            stdio: "ignore",
-        });
-        child.unref();
-        cleanupFns.push(() => {
-            try {
-                if (child.pid)
-                    process.kill(child.pid);
-            }
-            catch {
-                // skip
-            }
-        });
-    }
-    const port = await waitForDebugPort(userDataDir, DEBUG_PORT_WAIT_MS);
-    return {
-        port,
-        cleanup: () => cleanupFns.forEach((fn) => fn()),
-    };
-}
-async function extractHandleFromProfile(executablePath, profileRoot, profileName) {
-    const tempProfile = prepareProfileCopy(profileRoot, profileName);
-    if (!tempProfile)
+import { NAV_TIMEOUT_MS, scrapeFromChromeSession } from "./browser-session.js";
+async function extractTwitterHandle(context) {
+    const cookies = await context.cookies([
+        "https://x.com",
+        "https://twitter.com",
+    ]);
+    if (!cookies.find((c) => c.name === "auth_token"))
         return null;
-    const { port, cleanup } = await spawnChrome(executablePath, tempProfile);
-    let browser = null;
+    const page = await context.newPage();
     try {
-        if (!port)
-            return null;
-        browser = await chromium.connectOverCDP(`http://localhost:${port}`);
-        const contexts = browser.contexts();
-        const context = contexts[0] ?? (await browser.newContext());
-        const cookies = await context.cookies([
-            "https://x.com",
-            "https://twitter.com",
-        ]);
-        const authToken = cookies.find((c) => c.name === "auth_token");
-        if (!authToken)
+        await page.goto("https://x.com/home", {
+            waitUntil: "domcontentloaded",
+            timeout: NAV_TIMEOUT_MS,
+        });
+        if (/\/(login|i\/flow\/login)/.test(page.url()))
             return null;
-        const page = await context.newPage();
         try {
-            await page.goto("https://x.com/home", {
-                waitUntil: "domcontentloaded",
-                timeout: NAV_TIMEOUT_MS,
-            });
-            const url = page.url();
-            if (/\/(login|i\/flow\/login)/.test(url))
-                return null;
-            try {
-                const link = page.locator('[data-testid="AppTabBar_Profile_Link"]');
-                await link.first().waitFor({ timeout: 5000 });
-                const href = await link.first().getAttribute("href");
-                if (href) {
-                    const handle = href.replace(/^\//, "").trim();
-                    if (handle && !handle.includes("/"))
-                        return handle;
-                }
-            }
-            catch {
-                // fall through
-            }
-            try {
-                const nameElem = page.locator('[data-testid="UserName"] span:has-text("@")');
-                const text = await nameElem.first().innerText({ timeout: 3000 });
-                const match = text.match(/@([A-Za-z0-9_]+)/);
-                if (match)
-                    return match[1];
-            }
-            catch {
-                // skip
+            const link = page.locator('[data-testid="AppTabBar_Profile_Link"]');
+            await link.first().waitFor({ timeout: 5000 });
+            const href = await link.first().getAttribute("href");
+            if (href) {
+                const handle = href.replace(/^\//, "").trim();
+                if (handle && !handle.includes("/"))
+                    return handle;
             }
-            return null;
-        }
-        finally {
-            await page.close().catch(() => undefined);
         }
-    }
-    catch {
-        return null;
-    }
-    finally {
-        if (browser) {
-            await browser.close().catch(() => undefined);
+        catch {
+            // fall through
         }
-        cleanup();
-        await wait(500);
         try {
-            rmSync(tempProfile, { recursive: true, force: true });
+            const nameElem = page.locator('[data-testid="UserName"] span:has-text("@")');
+            const text = await nameElem.first().innerText({ timeout: 3000 });
+            const match = text.match(/@([A-Za-z0-9_]+)/);
+            if (match)
+                return match[1];
         }
         catch {
             // skip
         }
+        return null;
+    }
+    finally {
+        await page.close().catch(() => undefined);
     }
-}
-async function withTimeout(promise, ms) {
-    return Promise.race([
-        promise,
-        new Promise((resolve) => setTimeout(() => resolve(null), ms)),
-    ]);
 }
 export async function scrapeTwitterHandle() {
-    const executablePath = findChromeExecutable();
-    if (!executablePath)
-        return null;
-    const profileRoot = findChromeProfileRoot();
-    if (!profileRoot)
-        return null;
-    const profiles = listProfilesByMtime(profileRoot);
-    if (profiles.length === 0)
-        return null;
-    return withTimeout((async () => {
-        for (const profile of profiles) {
-            const handle = await extractHandleFromProfile(executablePath, profileRoot, profile).catch(() => null);
-            if (handle)
-                return handle;
-        }
-        return null;
-    })(), TOTAL_TIMEOUT_MS);
+    return scrapeFromChromeSession(extractTwitterHandle);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "standout",
-  "version": "0.5.30",
+  "version": "0.5.32",
   "description": "Build your developer profile with AI. One command, zero friction.",
   "type": "module",
   "main": "./dist/cli.js",
@@ -18,7 +18,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "dev": "tsx src/cli.ts",
+    "dev": "tsc && node dist/cli.js",
     "test": "tsx --test tests/*.test.ts",
     "preview:tiers": "tsx src/wrapped/preview.ts",
     "typecheck": "tsc --noEmit",