doordash-cli 0.3.3 → 0.4.1

package/dist/direct-api.js

@@ -1,11 +1,17 @@
+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 { createInterface } from "node:readline";
 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 ATTACHED_BROWSER_CDP_REACHABILITY_TIMEOUT_MS = 2_000;
+const ATTACHED_BROWSER_CDP_CONNECT_TIMEOUT_MS = 5_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 +703,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 +809,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 +847,179 @@ 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("");
+function buildAuthBootstrapSuccess(auth, message) {
+    if (!auth.isLoggedIn) {
+        return buildAuthBootstrapFailure(auth, message);
     }
-    finally {
-        rl.close();
-    }
-    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,
+    };
+}
+function canPromptForManagedBrowserConfirmation() {
+    return Boolean(process.stdin.isTTY);
+}
+function createManagedBrowserManualConfirmationHandle() {
+    if (!canPromptForManagedBrowserConfirmation()) {
+        return {
+            isEnabled: false,
+            consumeRequested: () => false,
+            close: () => { },
+        };
+    }
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stderr,
+        terminal: true,
+    });
+    let requested = false;
+    const onLine = () => {
+        requested = true;
+    };
+    rl.on("line", onLine);
+    return {
+        isEnabled: true,
+        consumeRequested: () => {
+            if (!requested) {
+                return false;
+            }
+            requested = false;
+            return true;
+        },
+        close: () => {
+            rl.off("line", onLine);
+            rl.close();
+        },
     };
 }
+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 attachable browser session I'm watching: ${AUTH_BOOTSTRAP_URL}`
+            : openedDefaultBrowser
+                ? `Found an attachable browser session, but couldn't drive it directly, so I opened DoorDash in your default browser: ${AUTH_BOOTSTRAP_URL}`
+                : `Detected an attachable browser session, but couldn't open DoorDash automatically. Open this URL in that watched browser to continue: ${AUTH_BOOTSTRAP_URL}`);
+        deps.log(`Detected ${reachableCandidates.length} attachable browser session(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 an attachable 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 attachable browser sessions 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 attachable browser sessions 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.`);
+    }
+    const desktopBrowserReuseGap = await deps.describeDesktopBrowserReuseGap().catch(() => null);
+    if (desktopBrowserReuseGap) {
+        deps.log(desktopBrowserReuseGap);
+    }
+    const manualManagedConfirmationAvailable = deps.canPromptForManagedBrowserConfirmation();
+    deps.log("I couldn't find an attachable browser session I can reuse, so I'm opening a temporary Chromium login window that the CLI can watch directly.");
+    deps.log(manualManagedConfirmationAvailable
+        ? `Finish signing in in that window. I'll keep checking automatically for up to ${Math.round(AUTH_BOOTSTRAP_TIMEOUT_MS / 1000)} seconds. If the page already shows you're signed in and the CLI still hasn't finished, press Enter here to force an immediate recheck.`
+        : `Finish signing in in that window. I'll keep checking automatically for up to ${Math.round(AUTH_BOOTSTRAP_TIMEOUT_MS / 1000)} seconds.`);
+    const managedAuth = await deps.waitForManagedBrowserLogin({
+        targetUrl: AUTH_BOOTSTRAP_URL,
+        timeoutMs: AUTH_BOOTSTRAP_TIMEOUT_MS,
+        pollIntervalMs: AUTH_BOOTSTRAP_POLL_INTERVAL_MS,
+        log: deps.log,
+    });
+    if (managedAuth.status === "completed") {
+        return buildAuthBootstrapSuccess(managedAuth.auth, managedAuth.completion === "manual"
+            ? "Opened a temporary Chromium login window. After you pressed Enter to confirm the browser login was complete, the CLI rechecked the signed-in session there and saved it for direct API use."
+            : "Opened a temporary Chromium login window, detected the signed-in session there automatically, and saved it for direct API use.");
+    }
+    if (managedAuth.status === "timed-out") {
+        return buildAuthBootstrapFailure(managedAuth.auth, manualManagedConfirmationAvailable
+            ? `Opened a temporary Chromium login window and watched for ${Math.round(AUTH_BOOTSTRAP_TIMEOUT_MS / 1000)} seconds, but I still couldn't prove an authenticated DoorDash session. If the browser already looks signed in, press Enter sooner next time to force an immediate recheck, or rerun dd-cli login.`
+            : `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 an attachable browser session the CLI can import, so I won't keep you waiting for the full login timeout. Once you've exposed an attachable 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, "An attachable 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 an attachable browser session the CLI can import. Finish signing in there, make an attachable browser session discoverable, then rerun `dd-cli login`."
+        : "Couldn't open a watchable browser automatically, and this environment still isn't exposing an attachable browser session the CLI can import. Open the DoorDash home page manually, make an attachable browser session discoverable, then rerun `dd-cli login`.");
+}
+export async function bootstrapAuthSession() {
+    return bootstrapAuthSessionWithDeps({
+        clearBlockedBrowserImport,
+        checkPersistedAuth: getPersistedAuthDirect,
+        importBrowserSessionIfAvailable,
+        markBrowserImportAttempted: () => session.markBrowserImportAttempted(),
+        getAttachedBrowserCdpCandidates,
+        getReachableCdpCandidates,
+        describeDesktopBrowserReuseGap,
+        openUrlInAttachedBrowser,
+        openUrlInDefaultBrowser,
+        waitForAttachedBrowserSessionImport,
+        waitForManagedBrowserLogin,
+        canPromptForManagedBrowserConfirmation,
+        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 +1691,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 +1700,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,45 +1715,57 @@ 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);
+            browser = await chromium.connectOverCDP(cdpUrl, { timeout: ATTACHED_BROWSER_CDP_CONNECT_TIMEOUT_MS });
             const context = browser.contexts()[0];
             if (!context) {
                 continue;
             }
             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 +1784,27 @@ 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 readLiveManagedBrowserAuth(page) {
+    if (!page || page.isClosed()) {
+        return buildAuthResult(null);
+    }
+    const consumerData = await fetchConsumerViaPage(page).catch(() => null);
+    return buildAuthResult(consumerData?.consumer ?? null);
+}
+async function confirmManagedBrowserAuth(context, page) {
+    const liveAuth = await readLiveManagedBrowserAuth(page);
+    if (liveAuth.isLoggedIn) {
+        if (context) {
+            await saveContextState(context).catch(() => { });
+        }
+        return liveAuth;
+    }
+    if (context) {
+        await saveContextState(context).catch(() => { });
+    }
+    return (await getPersistedAuthDirect().catch(() => null)) ?? liveAuth;
 }
 async function saveContextState(context, cookies = null) {
     const storageStatePath = getStorageStatePath();
@@ -1628,41 +1813,418 @@ 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);
     }
-    candidates.add("http://127.0.0.1:18800");
-    return [...candidates];
+    return false;
 }
-async function readOpenClawBrowserConfigCandidates() {
+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, { timeout: ATTACHED_BROWSER_CDP_CONNECT_TIMEOUT_MS });
+        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(() => { });
+    }
+}
+async function waitForManagedBrowserLogin(input) {
+    let browser = null;
+    let context = null;
+    let page = null;
+    const manualConfirmation = createManagedBrowserManualConfirmationHandle();
+    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) {
+            const liveAuth = await readLiveManagedBrowserAuth(page);
+            if (liveAuth.isLoggedIn) {
+                await saveContextState(context).catch(() => { });
+                return {
+                    status: "completed",
+                    completion: "automatic",
+                    auth: liveAuth,
+                };
+            }
+            if (manualConfirmation.consumeRequested()) {
+                const confirmedAuth = await confirmManagedBrowserAuth(context, page);
+                if (confirmedAuth.isLoggedIn) {
+                    return {
+                        status: "completed",
+                        completion: "manual",
+                        auth: confirmedAuth,
+                    };
+                }
+                input.log("Still not seeing an authenticated DoorDash session yet. Finish signing in in the opened browser window, then press Enter again or keep waiting for automatic detection.");
+            }
+            if (page.isClosed()) {
+                break;
+            }
+            if (Date.now() >= deadline) {
+                break;
+            }
+            await wait(input.pollIntervalMs);
+        }
+        const finalAuth = await confirmManagedBrowserAuth(context, page);
+        if (finalAuth.isLoggedIn) {
+            return {
+                status: "completed",
+                completion: "automatic",
+                auth: finalAuth,
+            };
+        }
+        return {
+            status: "timed-out",
+            auth: finalAuth,
+        };
+    }
+    catch (error) {
+        if (isPlaywrightBrowserInstallMissingError(error)) {
+            return { status: "launch-failed" };
+        }
+        return { status: "launch-failed" };
+    }
+    finally {
+        manualConfirmation.close();
+        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");
+}
+const KNOWN_DESKTOP_BROWSERS = [
+    {
+        label: "Brave",
+        processMatchers: [/\bbrave-browser(?:-stable)?\b/i, /\/brave(?:$|\s)/i],
+        devToolsActivePortPaths: [
+            join(homedir(), ".config", "BraveSoftware", "Brave-Browser", "DevToolsActivePort"),
+            join(homedir(), "Library", "Application Support", "BraveSoftware", "Brave-Browser", "DevToolsActivePort"),
+        ],
+    },
+    {
+        label: "Google Chrome",
+        processMatchers: [/\bgoogle-chrome(?:-stable|-beta|-unstable)?\b/i, /\/google-chrome(?:$|\s)/i],
+        devToolsActivePortPaths: [
+            join(homedir(), ".config", "google-chrome", "DevToolsActivePort"),
+            join(homedir(), "Library", "Application Support", "Google", "Chrome", "DevToolsActivePort"),
+        ],
+    },
+    {
+        label: "Microsoft Edge",
+        processMatchers: [/\bmicrosoft-edge(?:-stable|-beta|-dev)?\b/i, /\/microsoft-edge(?:$|\s)/i],
+        devToolsActivePortPaths: [
+            join(homedir(), ".config", "microsoft-edge", "DevToolsActivePort"),
+            join(homedir(), "Library", "Application Support", "Microsoft Edge", "DevToolsActivePort"),
+        ],
+    },
+    {
+        label: "Chromium",
+        processMatchers: [/\bchromium-browser\b/i, /\bchromium\b/i],
+        devToolsActivePortPaths: [
+            join(homedir(), ".config", "chromium", "DevToolsActivePort"),
+            join(homedir(), "Library", "Application Support", "Chromium", "DevToolsActivePort"),
+        ],
+    },
+];
+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);
+    });
+}
+function detectRunningDesktopBrowser(processCommands) {
+    const filteredCommands = processCommands
+        .map((command) => command.trim())
+        .filter((command) => command.length > 0)
+        .filter((command) => !/chrome-devtools-mcp/i.test(command));
+    for (const browser of KNOWN_DESKTOP_BROWSERS) {
+        const preferredMatch = filteredCommands.some((command) => !/--type=|crashpad|zygote/i.test(command) && browser.processMatchers.some((matcher) => matcher.test(command)));
+        if (preferredMatch) {
+            return browser;
+        }
+    }
+    for (const browser of KNOWN_DESKTOP_BROWSERS) {
+        if (filteredCommands.some((command) => browser.processMatchers.some((matcher) => matcher.test(command)))) {
+            return browser;
+        }
+    }
+    return null;
+}
+function hasRemoteDebuggingSignal(processCommands) {
+    return processCommands.some((command) => /--remote-debugging-(?:port|pipe)(?:=|\b)/i.test(command));
+}
+export function summarizeDesktopBrowserReuseGap(input) {
+    const browser = detectRunningDesktopBrowser(input.processCommands);
+    if (!browser) {
+        return null;
+    }
+    if (hasRemoteDebuggingSignal(input.processCommands) || input.hasAnyDevToolsActivePort) {
+        return null;
+    }
+    return `I can see ${browser.label} is already running on this desktop, but it is not exposing an attachable browser automation session right now. A normal open browser window is not automatically reusable; dd-cli can only import a browser session it can actually attach to.`;
+}
+async function captureCommandStdout(command, args) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "ignore"] });
+        const stdout = [];
+        child.once("error", reject);
+        child.stdout?.on("data", (chunk) => {
+            stdout.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        child.once("close", (code) => {
+            if (code === 0) {
+                resolve(Buffer.concat(stdout).toString("utf8"));
+                return;
+            }
+            reject(new Error(`${command} exited with code ${code ?? "null"}`));
+        });
+    });
+}
+async function listProcessCommands(targetPlatform = process.platform) {
+    if (targetPlatform === "win32") {
+        return [];
+    }
+    const args = targetPlatform === "darwin" ? ["-axo", "command="] : ["-eo", "command="];
+    const stdout = await captureCommandStdout("ps", args).catch(() => "");
+    return stdout
+        .split(/\r?\n/)
+        .map((command) => command.trim())
+        .filter((command) => command.length > 0);
+}
+async function hasAnyKnownDevToolsActivePort() {
+    for (const browser of KNOWN_DESKTOP_BROWSERS) {
+        for (const path of browser.devToolsActivePortPaths) {
+            if ((await readFile(path, "utf8").catch(() => null)) !== null) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+async function describeDesktopBrowserReuseGap() {
+    const processCommands = await listProcessCommands();
+    return summarizeDesktopBrowserReuseGap({
+        processCommands,
+        hasAnyDevToolsActivePort: await hasAnyKnownDevToolsActivePort(),
+    });
+}
+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 {
@@ -1671,7 +2233,9 @@ async function readOpenClawBrowserConfigCandidates() {
 }
 async function isCdpEndpointReachable(cdpUrl) {
     try {
-        const response = await fetch(`${cdpUrl.replace(/\/$/, "")}/json/version`);
+        const response = await fetch(`${cdpUrl.replace(/\/$/, "")}/json/version`, {
+            signal: AbortSignal.timeout(ATTACHED_BROWSER_CDP_REACHABILITY_TIMEOUT_MS),
+        });
         return response.ok;
     }
     catch {
@@ -2306,6 +2870,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");