doordash-cli 0.3.3 → 0.4.0

package/dist/direct-api.js

@@ -1,11 +1,14 @@
+import { spawn } from "node:child_process";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
 import { chromium } from "playwright";
-import { getCookiesPath, getStorageStatePath } from "./session-storage.js";
+import { getBrowserImportBlockPath, getCookiesPath, getStorageStatePath } from "./session-storage.js";
 const BASE_URL = "https://www.doordash.com";
+const AUTH_BOOTSTRAP_URL = `${BASE_URL}/home`;
+const AUTH_BOOTSTRAP_TIMEOUT_MS = 180_000;
+const AUTH_BOOTSTRAP_POLL_INTERVAL_MS = 2_000;
+const AUTH_BOOTSTRAP_NO_DISCOVERY_GRACE_MS = 10_000;
 const DEFAULT_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";
 const GRAPHQL_HEADERS = {
     accept: "*/*",
@@ -697,12 +700,12 @@ class DoorDashDirectSession {
     browser = null;
     context = null;
     page = null;
-    attemptedManagedImport = false;
+    attemptedBrowserImport = false;
     async init(options = {}) {
         if (this.page) {
             return this.page;
         }
-        await this.maybeImportManagedBrowserSession();
+        await this.maybeImportBrowserSession();
         const storageStatePath = getStorageStatePath();
         this.browser = await chromium.launch({
             headless: options.headed ? false : true,
@@ -803,21 +806,25 @@ class DoorDashDirectSession {
         }
         throw new Error(`DoorDash request failed for ${input.url}`);
     }
-    async maybeImportManagedBrowserSession() {
-        if (this.attemptedManagedImport) {
+    markBrowserImportAttempted() {
+        this.attemptedBrowserImport = true;
+    }
+    resetBrowserImportAttempted() {
+        this.attemptedBrowserImport = false;
+    }
+    async maybeImportBrowserSession() {
+        if (this.attemptedBrowserImport) {
             return;
         }
-        this.attemptedManagedImport = true;
-        if (await hasPersistedSessionArtifacts()) {
+        this.attemptedBrowserImport = true;
+        if (await hasBlockedBrowserImport()) {
             return;
         }
-        await importManagedBrowserSessionIfAvailable().catch(() => { });
+        await importBrowserSessionIfAvailable().catch(() => { });
     }
 }
 const session = new DoorDashDirectSession();
-export async function checkAuthDirect() {
-    const data = await session.graphql("consumer", CONSUMER_QUERY, {});
-    const consumer = data.consumer ?? null;
+function buildAuthResult(consumer) {
     return {
         success: true,
         isLoggedIn: Boolean(consumer && consumer.isGuest === false),
@@ -837,36 +844,127 @@ export async function checkAuthDirect() {
         storageStatePath: getStorageStatePath(),
     };
 }
-export async function bootstrapAuthSession() {
-    const page = await session.init({ headed: true });
-    console.error("A Chromium window is open for DoorDash session bootstrap.");
-    console.error("1) Sign in if needed.");
-    console.error("2) Confirm your delivery address if needed.");
-    console.error("3) Return here and press Enter to save the session for direct API use.");
-    await page.goto(`${BASE_URL}/home`, { waitUntil: "domcontentloaded", timeout: 90_000 }).catch(() => { });
-    const rl = createInterface({ input, output });
-    try {
-        await rl.question("");
-    }
-    finally {
-        rl.close();
+function buildAuthBootstrapSuccess(auth, message) {
+    if (!auth.isLoggedIn) {
+        return buildAuthBootstrapFailure(auth, message);
     }
-    await session.saveState();
-    const auth = await checkAuthDirect();
     return {
         ...auth,
-        message: auth.isLoggedIn
-            ? "DoorDash session saved for direct API use."
-            : "DoorDash session state saved, but the consumer still appears to be logged out or guest-only.",
+        success: true,
+        isLoggedIn: true,
+        message,
     };
 }
+function buildAuthBootstrapFailure(auth, message) {
+    const base = auth ?? buildAuthResult(null);
+    return {
+        ...base,
+        success: false,
+        isLoggedIn: false,
+        message,
+    };
+}
+export async function checkAuthDirect() {
+    const data = await session.graphql("consumer", CONSUMER_QUERY, {});
+    return buildAuthResult(data.consumer ?? null);
+}
+export async function bootstrapAuthSessionWithDeps(deps) {
+    await deps.clearBlockedBrowserImport().catch(() => { });
+    const persistedAuth = await deps.checkPersistedAuth().catch(() => null);
+    if (persistedAuth?.isLoggedIn) {
+        return buildAuthBootstrapSuccess(persistedAuth, "Already signed in with saved local DoorDash session state. No browser interaction was needed.");
+    }
+    const imported = await deps.importBrowserSessionIfAvailable().catch(() => false);
+    deps.markBrowserImportAttempted();
+    if (imported) {
+        const auth = await deps.checkAuthDirect();
+        return auth.isLoggedIn
+            ? buildAuthBootstrapSuccess(auth, "Imported an existing signed-in browser session and saved it for direct API use.")
+            : buildAuthBootstrapFailure(auth, "Imported browser session state, but the consumer still appears to be logged out or guest-only.");
+    }
+    const attachedCandidates = await deps.getAttachedBrowserCdpCandidates();
+    const reachableCandidates = await deps.getReachableCdpCandidates(attachedCandidates);
+    if (reachableCandidates.length > 0) {
+        const openedAttachedBrowser = await deps.openUrlInAttachedBrowser({
+            cdpUrl: reachableCandidates[0],
+            targetUrl: AUTH_BOOTSTRAP_URL,
+        });
+        const openedDefaultBrowser = openedAttachedBrowser ? false : await deps.openUrlInDefaultBrowser(AUTH_BOOTSTRAP_URL);
+        deps.log(openedAttachedBrowser
+            ? `Opened DoorDash in the reusable browser session I'm watching: ${AUTH_BOOTSTRAP_URL}`
+            : openedDefaultBrowser
+                ? `Found a reusable browser connection, but couldn't drive it directly, so I opened DoorDash in your default browser: ${AUTH_BOOTSTRAP_URL}`
+                : `Detected a reusable browser connection, but couldn't open DoorDash automatically. Open this URL in that watched browser to continue: ${AUTH_BOOTSTRAP_URL}`);
+        deps.log(`Detected ${reachableCandidates.length} reusable browser connection(s). Finish the sign-in in that browser window and I'll import it automatically for up to ${Math.round(AUTH_BOOTSTRAP_TIMEOUT_MS / 1000)} seconds.`);
+        const importedAfterWait = await deps.waitForAttachedBrowserSessionImport({
+            timeoutMs: AUTH_BOOTSTRAP_TIMEOUT_MS,
+            pollIntervalMs: AUTH_BOOTSTRAP_POLL_INTERVAL_MS,
+        });
+        const auth = await deps.checkAuthDirect();
+        if (importedAfterWait) {
+            return auth.isLoggedIn
+                ? buildAuthBootstrapSuccess(auth, "Opened DoorDash in a reusable browser session, detected the signed-in consumer state, and saved it for direct API use.")
+                : buildAuthBootstrapFailure(auth, "Detected browser session state in the watched browser, but the consumer still appears logged out or guest-only.");
+        }
+        return buildAuthBootstrapFailure(auth, openedAttachedBrowser || openedDefaultBrowser
+            ? `Opened DoorDash and watched reusable browser connections for ${Math.round(AUTH_BOOTSTRAP_TIMEOUT_MS / 1000)} seconds, but no signed-in DoorDash session was imported. Finish the login in that watched browser and rerun dd-cli login.`
+            : `Watched reusable browser connections for ${Math.round(AUTH_BOOTSTRAP_TIMEOUT_MS / 1000)} seconds without importing a signed-in DoorDash session. Open ${AUTH_BOOTSTRAP_URL} manually in the watched browser, finish signing in, then rerun dd-cli login.`);
+    }
+    deps.log("I couldn't find a reusable browser connection, so I'm opening a temporary Chromium login window that the CLI can watch directly.");
+    const managedAuth = await deps.waitForManagedBrowserLogin({
+        targetUrl: AUTH_BOOTSTRAP_URL,
+        timeoutMs: AUTH_BOOTSTRAP_TIMEOUT_MS,
+        pollIntervalMs: AUTH_BOOTSTRAP_POLL_INTERVAL_MS,
+    });
+    if (managedAuth) {
+        return managedAuth.isLoggedIn
+            ? buildAuthBootstrapSuccess(managedAuth, "Opened a temporary Chromium login window, detected the signed-in session there, and saved it for direct API use.")
+            : buildAuthBootstrapFailure(managedAuth, `Opened a temporary Chromium login window and watched for ${Math.round(AUTH_BOOTSTRAP_TIMEOUT_MS / 1000)} seconds, but no authenticated DoorDash session was established.`);
+    }
+    const openedBrowser = await deps.openUrlInDefaultBrowser(AUTH_BOOTSTRAP_URL);
+    deps.log(openedBrowser
+        ? `I couldn't launch the temporary Chromium login window, so I opened DoorDash in your default browser instead: ${AUTH_BOOTSTRAP_URL}`
+        : `Couldn't open the temporary Chromium login window or your default browser automatically. Open this URL to continue: ${AUTH_BOOTSTRAP_URL}`);
+    deps.log("This environment still isn't exposing a reusable browser session the CLI can import, so I won't keep you waiting for the full login timeout. Once you've exposed a compatible browser session, rerun `dd-cli login`.");
+    const importedAfterGrace = await deps.waitForAttachedBrowserSessionImport({
+        timeoutMs: AUTH_BOOTSTRAP_NO_DISCOVERY_GRACE_MS,
+        pollIntervalMs: AUTH_BOOTSTRAP_POLL_INTERVAL_MS,
+    });
+    const auth = await deps.checkAuthDirect();
+    if (importedAfterGrace) {
+        return auth.isLoggedIn
+            ? buildAuthBootstrapSuccess(auth, "A reusable browser session appeared a few seconds later and was saved for direct API use.")
+            : buildAuthBootstrapFailure(auth, "Detected browser session state after opening the browser, but the consumer still appears logged out or guest-only.");
+    }
+    return buildAuthBootstrapFailure(auth, openedBrowser
+        ? "Opened DoorDash in your default browser, but this environment still isn't exposing a reusable browser session the CLI can import. Finish signing in there, make a compatible browser session discoverable, then rerun `dd-cli login`."
+        : "Couldn't open a watchable browser automatically, and this environment still isn't exposing a reusable browser session the CLI can import. Open the DoorDash home page manually, make a compatible browser session discoverable, then rerun `dd-cli login`.");
+}
+export async function bootstrapAuthSession() {
+    return bootstrapAuthSessionWithDeps({
+        clearBlockedBrowserImport,
+        checkPersistedAuth: getPersistedAuthDirect,
+        importBrowserSessionIfAvailable,
+        markBrowserImportAttempted: () => session.markBrowserImportAttempted(),
+        getAttachedBrowserCdpCandidates,
+        getReachableCdpCandidates,
+        openUrlInAttachedBrowser,
+        openUrlInDefaultBrowser,
+        waitForAttachedBrowserSessionImport,
+        waitForManagedBrowserLogin,
+        checkAuthDirect,
+        log: (message) => console.error(message),
+    });
+}
 export async function clearStoredSession() {
     await session.close();
+    session.resetBrowserImportAttempted();
     await rm(getCookiesPath(), { force: true }).catch(() => { });
     await rm(getStorageStatePath(), { force: true }).catch(() => { });
+    await blockBrowserImport();
     return {
         success: true,
-        message: "DoorDash cookies and stored browser session state cleared.",
+        message: "DoorDash cookies and stored browser session state cleared. Automatic browser-session reuse is disabled until the next `dd-cli login`.",
         cookiesPath: getCookiesPath(),
         storageStatePath: getStorageStatePath(),
     };
@@ -1538,7 +1636,7 @@ function normalizeAddressText(value) {
         .replace(/[.,]/g, "")
         .replace(/\s+/g, " ");
 }
-export function isDoorDashUrl(value) {
+function isDoorDashUrl(value) {
     try {
         const url = new URL(value);
         return url.hostname === "doordash.com" || url.hostname.endsWith(".doordash.com");
@@ -1547,13 +1645,13 @@ export function isDoorDashUrl(value) {
         return false;
     }
 }
-export function hasDoorDashCookies(cookies) {
+function hasDoorDashCookies(cookies) {
     return cookies.some((cookie) => {
         const domain = cookie.domain.trim().replace(/^\./, "").toLowerCase();
         return domain === "doordash.com" || domain.endsWith(".doordash.com");
     });
 }
-export function selectManagedBrowserImportMode(input) {
+export function selectAttachedBrowserImportMode(input) {
     if (input.pageUrls.some((url) => isDoorDashUrl(url))) {
         return "page";
     }
@@ -1562,12 +1660,16 @@ export function selectManagedBrowserImportMode(input) {
     }
     return "skip";
 }
-async function importManagedBrowserSessionIfAvailable() {
-    for (const cdpUrl of await getManagedBrowserCdpCandidates()) {
+async function importBrowserSessionIfAvailable() {
+    return await importBrowserSessionFromCdpCandidates(await getAttachedBrowserCdpCandidates());
+}
+async function importBrowserSessionFromCdpCandidates(candidates) {
+    for (const cdpUrl of candidates) {
         if (!(await isCdpEndpointReachable(cdpUrl))) {
             continue;
         }
         let browser = null;
+        let tempPage = null;
         try {
             browser = await chromium.connectOverCDP(cdpUrl);
             const context = browser.contexts()[0];
@@ -1576,31 +1678,39 @@ async function importManagedBrowserSessionIfAvailable() {
             }
             const cookies = await context.cookies();
             const pages = context.pages();
-            const reusablePage = pages.find((candidate) => isDoorDashUrl(candidate.url())) ?? null;
-            const importMode = selectManagedBrowserImportMode({
-                pageUrls: reusablePage ? [reusablePage.url()] : [],
+            const importMode = selectAttachedBrowserImportMode({
+                pageUrls: pages.map((candidate) => candidate.url()),
                 cookies,
             });
             if (importMode === "skip") {
                 continue;
             }
-            if (reusablePage) {
-                const consumerData = await fetchConsumerViaPage(reusablePage).catch(() => null);
-                const consumer = consumerData?.consumer ?? null;
-                if (consumer?.isGuest === false) {
-                    await saveContextState(context, cookies);
+            if (importMode === "cookies") {
+                await saveContextState(context, cookies);
+                if (await validatePersistedDirectSessionArtifacts()) {
                     return true;
                 }
             }
-            if (hasDoorDashCookies(cookies)) {
-                await saveContextState(context, cookies);
-                return true;
+            let page = pages.find((candidate) => isDoorDashUrl(candidate.url())) ?? null;
+            if (!page) {
+                tempPage = await context.newPage();
+                page = tempPage;
+                await page.goto(`${BASE_URL}/home`, { waitUntil: "domcontentloaded", timeout: 90_000 }).catch(() => { });
+                await page.waitForTimeout(1_000);
             }
+            const consumerData = await fetchConsumerViaPage(page).catch(() => null);
+            const consumer = consumerData?.consumer ?? null;
+            if (!consumer || consumer.isGuest !== false) {
+                continue;
+            }
+            await saveContextState(context, cookies);
+            return true;
         }
         catch {
             continue;
         }
         finally {
+            await tempPage?.close().catch(() => { });
             await browser?.close().catch(() => { });
         }
     }
@@ -1619,7 +1729,7 @@ async function fetchConsumerViaPage(page) {
         headers: GRAPHQL_HEADERS,
         url: `${BASE_URL}/graphql/consumer?operation=consumer`,
     });
-    return parseGraphQlResponse("managedBrowserConsumerImport", raw.status, raw.text);
+    return parseGraphQlResponse("attachedBrowserConsumerImport", raw.status, raw.text);
 }
 async function saveContextState(context, cookies = null) {
     const storageStatePath = getStorageStatePath();
@@ -1628,41 +1738,281 @@ async function saveContextState(context, cookies = null) {
     const resolvedCookies = cookies ?? (await context.cookies());
     await writeFile(getCookiesPath(), JSON.stringify(resolvedCookies, null, 2));
 }
-async function getManagedBrowserCdpCandidates() {
+async function getPersistedAuthDirect() {
+    if (!(await hasPersistedSessionArtifacts())) {
+        return null;
+    }
+    let browser = null;
+    let context = null;
+    let page = null;
+    try {
+        browser = await chromium.launch({
+            headless: true,
+            args: ["--disable-blink-features=AutomationControlled", "--no-sandbox", "--disable-setuid-sandbox"],
+        });
+        const storageStatePath = getStorageStatePath();
+        const hasStorage = await hasStorageState();
+        context = await browser.newContext({
+            userAgent: DEFAULT_USER_AGENT,
+            locale: "en-US",
+            viewport: { width: 1280, height: 900 },
+            ...(hasStorage ? { storageState: storageStatePath } : {}),
+        });
+        if (!hasStorage) {
+            const cookies = await readStoredCookies();
+            if (cookies.length === 0) {
+                return null;
+            }
+            await context.addCookies(cookies);
+        }
+        page = await context.newPage();
+        await page.goto(`${BASE_URL}/home`, { waitUntil: "domcontentloaded", timeout: 90_000 }).catch(() => { });
+        await page.waitForTimeout(1_000);
+        const consumerData = await fetchConsumerViaPage(page).catch(() => null);
+        return buildAuthResult(consumerData?.consumer ?? null);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await page?.close().catch(() => { });
+        await context?.close().catch(() => { });
+        await browser?.close().catch(() => { });
+    }
+}
+async function validatePersistedDirectSessionArtifacts() {
+    const auth = await getPersistedAuthDirect();
+    return auth?.isLoggedIn === true;
+}
+export function resolveAttachedBrowserCdpCandidates(env, configCandidates = []) {
     const candidates = new Set();
-    for (const value of [
-        process.env.DOORDASH_MANAGED_BROWSER_CDP_URL,
-        process.env.OPENCLAW_BROWSER_CDP_URL,
-        process.env.OPENCLAW_OPENCLAW_CDP_URL,
-    ]) {
+    const addCandidate = (value) => {
         if (typeof value === "string" && value.trim().length > 0) {
-            candidates.add(value.trim().replace(/\/$/, ""));
+            candidates.add(normalizeCdpCandidate(value));
+        }
+    };
+    addCdpCandidatesFromList(candidates, env.DOORDASH_ATTACHED_BROWSER_CDP_URLS);
+    addCdpCandidatesFromList(candidates, env.DOORDASH_BROWSER_CDP_URLS);
+    addCandidate(env.DOORDASH_ATTACHED_BROWSER_CDP_URL);
+    addCandidate(env.DOORDASH_BROWSER_CDP_URL);
+    addCdpPortCandidatesFromList(candidates, env.DOORDASH_BROWSER_CDP_PORTS);
+    const portCandidate = parseCdpPortCandidate(env.DOORDASH_BROWSER_CDP_PORT);
+    if (portCandidate) {
+        candidates.add(portCandidate);
+    }
+    for (const compatibilityValue of [env.DOORDASH_MANAGED_BROWSER_CDP_URL, env.OPENCLAW_BROWSER_CDP_URL, env.OPENCLAW_OPENCLAW_CDP_URL]) {
+        addCandidate(compatibilityValue);
+    }
+    for (const value of configCandidates) {
+        addCandidate(value);
+    }
+    addCandidate("http://127.0.0.1:18792");
+    addCandidate("http://127.0.0.1:18800");
+    addCandidate("http://127.0.0.1:9222");
+    return [...candidates];
+}
+async function getAttachedBrowserCdpCandidates() {
+    const configCandidates = await readOpenClawBrowserConfigCandidates({ profileNames: ["user", "chrome", "openclaw"] });
+    return resolveAttachedBrowserCdpCandidates(process.env, configCandidates);
+}
+async function getReachableCdpCandidates(candidates) {
+    const reachable = [];
+    for (const cdpUrl of candidates) {
+        if (await isCdpEndpointReachable(cdpUrl)) {
+            reachable.push(cdpUrl);
         }
     }
-    for (const value of await readOpenClawBrowserConfigCandidates()) {
-        candidates.add(value.replace(/\/$/, ""));
+    return reachable;
+}
+async function waitForAttachedBrowserSessionImport(input) {
+    const deadline = Date.now() + input.timeoutMs;
+    while (Date.now() <= deadline) {
+        if (await importBrowserSessionIfAvailable().catch(() => false)) {
+            return true;
+        }
+        if (Date.now() >= deadline) {
+            break;
+        }
+        await wait(input.pollIntervalMs);
+    }
+    return false;
+}
+export function resolveSystemBrowserOpenCommand(targetUrl, targetPlatform = process.platform) {
+    if (targetPlatform === "darwin") {
+        return { command: "open", args: [targetUrl] };
+    }
+    if (targetPlatform === "win32") {
+        return { command: "cmd", args: ["/c", "start", "", targetUrl] };
+    }
+    if (["linux", "freebsd", "openbsd", "netbsd", "sunos", "android"].includes(targetPlatform)) {
+        return { command: "xdg-open", args: [targetUrl] };
+    }
+    return null;
+}
+async function openUrlInDefaultBrowser(targetUrl) {
+    const command = resolveSystemBrowserOpenCommand(targetUrl);
+    if (!command) {
+        return false;
+    }
+    return await new Promise((resolve) => {
+        const child = spawn(command.command, command.args, {
+            detached: process.platform !== "win32",
+            stdio: "ignore",
+        });
+        child.once("error", () => resolve(false));
+        child.once("spawn", () => {
+            child.unref();
+            resolve(true);
+        });
+    });
+}
+async function openUrlInAttachedBrowser(input) {
+    let browser = null;
+    try {
+        browser = await chromium.connectOverCDP(input.cdpUrl);
+        const context = browser.contexts()[0];
+        if (!context) {
+            return false;
+        }
+        let page = context.pages().find((candidate) => isDoorDashUrl(candidate.url())) ?? null;
+        if (!page) {
+            page = await context.newPage();
+        }
+        await page.goto(input.targetUrl, { waitUntil: "domcontentloaded", timeout: 90_000 }).catch(() => { });
+        await page.bringToFront().catch(() => { });
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await browser?.close().catch(() => { });
     }
-    candidates.add("http://127.0.0.1:18800");
-    return [...candidates];
 }
-async function readOpenClawBrowserConfigCandidates() {
+async function waitForManagedBrowserLogin(input) {
+    let browser = null;
+    let context = null;
+    let page = null;
+    try {
+        browser = await chromium.launch({
+            headless: false,
+            args: ["--disable-blink-features=AutomationControlled", "--no-sandbox", "--disable-setuid-sandbox"],
+        });
+        const storageStatePath = getStorageStatePath();
+        const hasStorage = await hasStorageState();
+        context = await browser.newContext({
+            userAgent: DEFAULT_USER_AGENT,
+            locale: "en-US",
+            viewport: { width: 1280, height: 900 },
+            ...(hasStorage ? { storageState: storageStatePath } : {}),
+        });
+        if (!hasStorage) {
+            const cookies = await readStoredCookies();
+            if (cookies.length > 0) {
+                await context.addCookies(cookies);
+            }
+        }
+        page = await context.newPage();
+        await page.goto(input.targetUrl, { waitUntil: "domcontentloaded", timeout: 90_000 }).catch(() => { });
+        await page.bringToFront().catch(() => { });
+        const deadline = Date.now() + input.timeoutMs;
+        while (Date.now() <= deadline) {
+            await saveContextState(context).catch(() => { });
+            const auth = await getPersistedAuthDirect();
+            if (auth?.isLoggedIn) {
+                return auth;
+            }
+            if (page.isClosed()) {
+                break;
+            }
+            if (Date.now() >= deadline) {
+                break;
+            }
+            await wait(input.pollIntervalMs);
+        }
+        await saveContextState(context).catch(() => { });
+        return (await getPersistedAuthDirect()) ?? buildAuthResult(null);
+    }
+    catch (error) {
+        if (isPlaywrightBrowserInstallMissingError(error)) {
+            return null;
+        }
+        return null;
+    }
+    finally {
+        await page?.close().catch(() => { });
+        await context?.close().catch(() => { });
+        await browser?.close().catch(() => { });
+    }
+}
+function isPlaywrightBrowserInstallMissingError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const message = error.message.toLowerCase();
+    return message.includes("executable doesn't exist") || message.includes("please run the following command") || message.includes("playwright install");
+}
+function normalizeCdpCandidate(value) {
+    return value.trim().replace(/\/$/, "");
+}
+function addCdpCandidatesFromList(candidates, value) {
+    if (!value) {
+        return;
+    }
+    for (const entry of value.split(/[,\n]/)) {
+        const trimmed = entry.trim();
+        if (trimmed) {
+            candidates.add(normalizeCdpCandidate(trimmed));
+        }
+    }
+}
+function addCdpPortCandidatesFromList(candidates, value) {
+    if (!value) {
+        return;
+    }
+    for (const entry of value.split(/[,\n]/)) {
+        const portCandidate = parseCdpPortCandidate(entry.trim());
+        if (portCandidate) {
+            candidates.add(portCandidate);
+        }
+    }
+}
+function parseCdpPortCandidate(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        return null;
+    }
+    return `http://127.0.0.1:${parsed}`;
+}
+function appendBrowserConfigCandidate(candidates, value) {
+    const object = asObject(value);
+    if (typeof object.cdpUrl === "string" && object.cdpUrl.trim()) {
+        candidates.push(normalizeCdpCandidate(object.cdpUrl));
+    }
+    else if (typeof object.cdpPort === "number" && Number.isInteger(object.cdpPort)) {
+        candidates.push(`http://127.0.0.1:${object.cdpPort}`);
+    }
+}
+function wait(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+async function readOpenClawBrowserConfigCandidates(input) {
     try {
         const raw = await readFile(join(homedir(), ".openclaw", "openclaw.json"), "utf8");
         const parsed = safeJsonParse(raw);
         const browserConfig = asObject(parsed?.browser);
+        const profiles = asObject(browserConfig.profiles);
         const candidates = [];
-        const pushCandidate = (value) => {
-            const object = asObject(value);
-            if (typeof object.cdpUrl === "string" && object.cdpUrl.trim()) {
-                candidates.push(object.cdpUrl.trim());
-            }
-            else if (typeof object.cdpPort === "number" && Number.isInteger(object.cdpPort)) {
-                candidates.push(`http://127.0.0.1:${object.cdpPort}`);
-            }
-        };
-        pushCandidate(browserConfig);
-        pushCandidate(browserConfig.openclaw);
-        pushCandidate(asObject(browserConfig.profiles).openclaw);
+        appendBrowserConfigCandidate(candidates, browserConfig);
+        appendBrowserConfigCandidate(candidates, browserConfig.openclaw);
+        for (const profileName of input.profileNames) {
+            appendBrowserConfigCandidate(candidates, profiles[profileName]);
+        }
         return dedupeBy(candidates, (value) => value);
     }
     catch {
@@ -2306,6 +2656,22 @@ function truncate(value, length) {
 async function ensureConfigDir() {
     await mkdir(dirname(getCookiesPath()), { recursive: true });
 }
+async function hasBlockedBrowserImport() {
+    try {
+        await readFile(getBrowserImportBlockPath(), "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function blockBrowserImport() {
+    await ensureConfigDir();
+    await writeFile(getBrowserImportBlockPath(), "logged-out\n");
+}
+async function clearBlockedBrowserImport() {
+    await rm(getBrowserImportBlockPath(), { force: true }).catch(() => { });
+}
 async function hasStorageState() {
     try {
         await readFile(getStorageStatePath(), "utf8");