indiecrm-cli 0.1.0 → 0.2.1

package/dist/chrome-browser.js

@@ -0,0 +1,231 @@
+import { chmod, lstat, mkdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+const ORIGIN = "https://www.linkedin.com";
+const LOGIN_HELP = "Run indiecrm browser:connect, sign in to LinkedIn Sales Navigator in the dedicated Chrome window, then rerun with the same --out-dir. Saved work is preserved.";
+export class ChromeResearchError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "ChromeResearchError";
+    }
+}
+export class ChromeResearchInterruptedError extends Error {
+    signal;
+    constructor(signal) {
+        super("Research interrupted. Completed searches remain saved; rerun with the same --out-dir to resume.");
+        this.signal = signal;
+        this.name = "ChromeResearchInterruptedError";
+    }
+}
+export function validateChromeResearchUrl(value) {
+    const url = new URL(value);
+    if (url.origin !== ORIGIN || url.username || url.password || url.hash ||
+        !/^\/sales-api\/(?:salesApiAccountSearch|salesApiLeadSearch|salesApiCompanies)(?:\/\d+)?$/.test(url.pathname)) {
+        throw new Error("Chrome research only permits LinkedIn Sales Navigator company and people GET requests.");
+    }
+    // Preserve native Rest.li encoding; URLSearchParams can corrupt its syntax.
+    return value;
+}
+/** Only these native request headers enter memory; cookies/storage are never read or exported. */
+export function researchHeaders(headers) {
+    const lower = Object.fromEntries(Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v]));
+    if (!lower["csrf-token"] || !lower["x-li-identity"])
+        return null;
+    return { "csrf-token": lower["csrf-token"], "x-li-identity": lower["x-li-identity"], accept: "*/*", "x-restli-protocol-version": "2.0.0" };
+}
+export function chromeProfileDirectory() {
+    return path.resolve(process.env.SALESPROMPTER_CONFIG_DIR?.trim() || path.join(os.homedir(), ".config", "salesprompter"), "chrome-research");
+}
+/** Launch only a CLI-owned profile and private OS pipe; no debugging port or default-profile attachment. */
+export async function launchResearchChrome(visible = false) {
+    const profile = chromeProfileDirectory();
+    try {
+        if ((await lstat(profile)).isSymbolicLink())
+            throw new Error("The research Chrome profile must not be a symlink.");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    await mkdir(profile, { recursive: true, mode: 0o700 });
+    await chmod(profile, 0o700);
+    const { default: puppeteer } = await import("puppeteer-core");
+    try {
+        return await puppeteer.launch({ channel: "chrome", userDataDir: profile, pipe: true, headless: !visible,
+            timeout: 30000, protocolTimeout: 45000, defaultViewport: null,
+            // Let the command unwind its checkpoint/lock finally blocks before exiting.
+            handleSIGINT: false, handleSIGTERM: false, handleSIGHUP: false,
+        });
+    }
+    catch {
+        // Launch errors can contain paths/flags. Never forward raw browser stderr or credential-bearing URLs.
+        throw new ChromeResearchError("Could not start the dedicated research Chrome. Install/update Google Chrome and close any other indiecrm browser:connect or Chrome research run. Your everyday Chrome can stay open.");
+    }
+}
+export function parseChromeResearchResult(result) {
+    if (result.status === 429 || result.status === 999)
+        throw new ChromeResearchError(`LinkedIn returned HTTP ${result.status}. Research stopped; wait for cooldown before resuming the same checkpoint. No session switching or retry was attempted.`, result.status);
+    if (result.redirected || result.status === 401 || result.status === 403)
+        throw new ChromeResearchError(LOGIN_HELP, result.status);
+    if (result.status !== 200)
+        throw new ChromeResearchError(`LinkedIn research failed with HTTP ${result.status}. Saved work is preserved.`, result.status);
+    try {
+        return JSON.parse(result.text);
+    }
+    catch {
+        throw new ChromeResearchError(`LinkedIn did not return research JSON. ${LOGIN_HELP}`);
+    }
+}
+/** Lazy and serial: reopening a completed checkpoint never starts Chrome. */
+export function createChromeResearchBrowser(options = {}, launch = launchResearchChrome) {
+    let browser;
+    let page;
+    let headers = null;
+    let identity;
+    let fatal;
+    let initialization;
+    let closed = false;
+    let busy = false;
+    let browserClosing;
+    const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+    const signalHandlers = signals.map(signal => () => {
+        if (fatal instanceof ChromeResearchInterruptedError)
+            return;
+        fatal = new ChromeResearchInterruptedError(signal);
+        closed = true;
+        void closeOwnedBrowser().catch(() => { });
+    });
+    function closeOwnedBrowser() {
+        if (browser)
+            browserClosing ??= browser.close();
+        return browserClosing ?? Promise.resolve();
+    }
+    const waitMs = options.loginWaitMs ?? 30000;
+    if (!Number.isFinite(waitMs) || waitMs < 0 || waitMs > 3600000)
+        throw new Error("Chrome login wait must be between 0 and 3600 seconds.");
+    async function initialize() {
+        signals.forEach((signal, index) => process.on(signal, signalHandlers[index]));
+        browser = await launch(options.visible);
+        if (closed) {
+            await closeOwnedBrowser();
+            throw fatal ?? new ChromeResearchError("Research Chrome connection was cancelled.");
+        }
+        page = await browser.newPage();
+        page.on("response", (response) => {
+            if (fatal)
+                return;
+            const url = new URL(response.url());
+            if (url.origin !== ORIGIN)
+                return;
+            if (response.status() === 429 || response.status() === 999) {
+                fatal = new ChromeResearchError(`LinkedIn returned HTTP ${response.status()}. Stop and wait for cooldown before resuming.`, response.status());
+                return;
+            }
+            if (!url.pathname.startsWith("/sales-api/"))
+                return;
+            if (response.status() !== 200)
+                return;
+            const next = researchHeaders(response.request().headers());
+            if (!next)
+                return;
+            if (identity && identity !== next["x-li-identity"]) {
+                fatal = new ChromeResearchError("LinkedIn identity changed during research. Stopped without switching accounts.");
+                return;
+            }
+            identity = next["x-li-identity"];
+            headers = next;
+        });
+        options.onProgress?.(options.visible
+            ? "Sign in to Sales Navigator in the dedicated research Chrome window. The CLI will detect the connection automatically; no extension or browser worker is required."
+            : "Connecting to the saved research Chrome profile (no external browser worker).");
+        try {
+            await page.goto(`${ORIGIN}/sales/search/people`, { waitUntil: "domcontentloaded", timeout: 30000 });
+        }
+        catch {
+            if (closed)
+                throw fatal ?? new ChromeResearchError("Research Chrome connection was cancelled.");
+            if (!browser.connected)
+                throw new ChromeResearchError("Research Chrome closed before connecting.");
+        }
+        const deadline = Date.now() + waitMs;
+        let noticeAt = Date.now() + 30000;
+        while (!headers) {
+            if (closed)
+                throw fatal ?? new ChromeResearchError("Research Chrome connection was cancelled.");
+            if (fatal)
+                throw fatal;
+            if (!browser.connected || page.isClosed())
+                throw new ChromeResearchError("Research Chrome was closed before sign-in completed.");
+            const location = new URL(page.url());
+            const needsLogin = location.origin !== ORIGIN || /\/(?:login|checkpoint|authwall|uas)\b/.test(location.pathname);
+            if ((!options.visible && needsLogin) || Date.now() >= deadline)
+                throw new ChromeResearchError(LOGIN_HELP);
+            if (Date.now() >= noticeAt) {
+                options.onProgress?.("Waiting for Sales Navigator sign-in. Complete any sign-in or security check yourself in the research Chrome window.");
+                noticeAt += 30000;
+            }
+            await sleep(250);
+        }
+        if (fatal)
+            throw fatal;
+        options.onProgress?.("Research Chrome connected. Requests now run directly in the CLI.");
+    }
+    async function ready() {
+        if (closed)
+            throw fatal ?? new Error("Research Chrome is closed.");
+        initialization ??= initialize();
+        await initialization;
+        if (fatal)
+            throw fatal;
+    }
+    return {
+        // Compatibility with the existing request adapter, without opening any listener.
+        port: 0,
+        async connect() { await ready(); return { browser: "chrome", connected: true, workerRequired: false, profile: chromeProfileDirectory() }; },
+        async request(request) {
+            validateChromeResearchUrl(request.url);
+            if (busy)
+                throw new Error("Chrome research is single-worker; concurrent requests are not allowed.");
+            busy = true;
+            try {
+                await ready();
+                if (new URL(page.url()).origin !== ORIGIN)
+                    throw new ChromeResearchError(LOGIN_HELP);
+                // Serialize URL and allowlisted native headers as data, never concatenate raw input into executable code.
+                // Credentials remain browser-managed. Reject redirects to login/challenge pages instead of parsing HTML.
+                const result = await page.evaluate(`(async () => {
+          const response = await fetch(${JSON.stringify(request.url)}, {
+            method: 'GET', credentials: 'include', redirect: 'error',
+            headers: ${JSON.stringify(headers)}, signal: AbortSignal.timeout(30000)
+          });
+          const text = await response.text();
+          if (text.length > 50 * 1024 * 1024) throw new Error('Research response exceeded 50 MB');
+          return {status: response.status, text, redirected: response.redirected, retryAfter: response.headers.get('retry-after')};
+        })()`).catch(() => { throw fatal ?? new ChromeResearchError(`Chrome research request could not complete. ${LOGIN_HELP}`); });
+                const body = parseChromeResearchResult(result);
+                if (fatal)
+                    throw fatal;
+                return { body, retryCount: 0, retryDelayMs: 0 };
+            }
+            finally {
+                busy = false;
+            }
+        },
+        async close() {
+            closed = true;
+            try {
+                await closeOwnedBrowser();
+                await initialization?.catch(() => { });
+                await closeOwnedBrowser();
+            }
+            finally {
+                signals.forEach((signal, index) => process.off(signal, signalHandlers[index]));
+                headers = null;
+                identity = undefined;
+            }
+        },
+    };
+}