standout 0.1.0 → 0.2.0

package/dist/twitter-scrape.js

@@ -0,0 +1,267 @@
+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)
+        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());
+        const cookies = await context.cookies([
+            "https://x.com",
+            "https://twitter.com",
+        ]);
+        const authToken = cookies.find((c) => c.name === "auth_token");
+        if (!authToken)
+            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
+            }
+            return null;
+        }
+        finally {
+            await page.close().catch(() => undefined);
+        }
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (browser) {
+            await browser.close().catch(() => undefined);
+        }
+        cleanup();
+        await wait(500);
+        try {
+            rmSync(tempProfile, { recursive: true, force: true });
+        }
+        catch {
+            // skip
+        }
+    }
+}
+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);
+}

package/dist/wrapped/aggregate.d.ts

@@ -0,0 +1,6 @@
+import type { WrappedAggregateView } from "./types.js";
+export declare function aggregateView(args: {
+    profile: Record<string, unknown>;
+    computed: Record<string, unknown>;
+    share_url: string;
+}): WrappedAggregateView;