doordash-cli 0.4.0 → 0.4.2

package/dist/direct-api.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { bootstrapAuthSessionWithDeps, buildAddConsumerAddressPayload, buildAddToCartPayload, buildUpdateCartPayload, extractExistingOrdersFromApolloCache, normalizeItemName, parseExistingOrderLifecycleStatus, parseExistingOrdersResponse, parseOptionSelectionsJson, parseSearchRestaurantRow, resolveAttachedBrowserCdpCandidates, resolveAvailableAddressMatch, resolveSystemBrowserOpenCommand, selectAttachedBrowserImportMode, } from "./direct-api.js";
+import { bootstrapAuthSessionWithDeps, buildAddConsumerAddressPayload, buildAddToCartPayload, buildUpdateCartPayload, extractExistingOrdersFromApolloCache, normalizeItemName, parseExistingOrderLifecycleStatus, parseExistingOrdersResponse, parseOptionSelectionsJson, parseSearchRestaurantRow, preferredBrowserSessionImportStrategies, resolveAttachedBrowserCdpCandidates, resolveAvailableAddressMatch, resolveSystemBrowserOpenCommand, selectAttachedBrowserImportMode, summarizeDesktopBrowserReuseGap, } from "./direct-api.js";
 function configurableItemDetail() {
     return {
         success: true,
@@ -181,6 +181,35 @@ test("resolveSystemBrowserOpenCommand stays generic across operating systems", (
         args: ["/c", "start", "", "https://www.doordash.com/home"],
     });
 });
+test("summarizeDesktopBrowserReuseGap explains why a running Brave session still was not reusable", () => {
+    const message = summarizeDesktopBrowserReuseGap({
+        processCommands: [
+            "/bin/bash /usr/bin/brave-browser-stable",
+            "/opt/brave.com/brave/brave",
+            "/opt/brave.com/brave/brave --type=renderer",
+        ],
+        hasAnyDevToolsActivePort: false,
+    });
+    assert.match(message ?? "", /Brave is already running on this desktop/i);
+    assert.match(message ?? "", /couldn't reuse it automatically/i);
+    assert.match(message ?? "", /attachable browser automation session/i);
+    assert.match(message ?? "", /no importable signed-in DoorDash browser profile state was found/i);
+});
+test("summarizeDesktopBrowserReuseGap stays quiet once the browser exposes attach signals", () => {
+    assert.equal(summarizeDesktopBrowserReuseGap({
+        processCommands: ["/bin/bash /usr/bin/brave-browser-stable --remote-debugging-port=9222"],
+        hasAnyDevToolsActivePort: false,
+    }), null);
+    assert.equal(summarizeDesktopBrowserReuseGap({
+        processCommands: ["/bin/bash /usr/bin/brave-browser-stable"],
+        hasAnyDevToolsActivePort: true,
+    }), null);
+});
+test("preferredBrowserSessionImportStrategies prefers same-machine linux profile imports before CDP attach", () => {
+    assert.deepEqual(preferredBrowserSessionImportStrategies("linux"), ["local-linux-chromium-profile", "attached-browser-cdp"]);
+    assert.deepEqual(preferredBrowserSessionImportStrategies("darwin"), ["attached-browser-cdp"]);
+    assert.deepEqual(preferredBrowserSessionImportStrategies("win32"), ["attached-browser-cdp"]);
+});
 test("selectAttachedBrowserImportMode treats an authenticated browser with DoorDash cookies as an immediate import candidate", () => {
     assert.equal(selectAttachedBrowserImportMode({
         pageUrls: ["https://github.com/LatencyTDH/doordash-cli/pulls"],
@@ -229,6 +258,7 @@ test("bootstrapAuthSessionWithDeps returns immediately when saved local auth is
         getReachableCdpCandidates: async () => {
             throw new Error("should not probe reachability when saved auth is already valid");
         },
+        describeDesktopBrowserReuseGap: async () => null,
         openUrlInAttachedBrowser: async () => {
             throw new Error("should not try to open an attached browser when saved auth is already valid");
         },
@@ -243,6 +273,7 @@ test("bootstrapAuthSessionWithDeps returns immediately when saved local auth is
         waitForManagedBrowserLogin: async () => {
             throw new Error("should not launch a managed browser when saved auth is already valid");
         },
+        canPromptForManagedBrowserConfirmation: () => false,
         checkAuthDirect: async () => {
             throw new Error("should not re-check auth through the live session when saved auth is already valid");
         },
@@ -288,6 +319,7 @@ test("bootstrapAuthSessionWithDeps returns immediately when an attached browser
         getReachableCdpCandidates: async () => {
             throw new Error("should not probe reachability on immediate browser-session import");
         },
+        describeDesktopBrowserReuseGap: async () => null,
         openUrlInAttachedBrowser: async () => {
             throw new Error("should not open a browser when immediate browser-session import succeeded");
         },
@@ -302,6 +334,7 @@ test("bootstrapAuthSessionWithDeps returns immediately when an attached browser
         waitForManagedBrowserLogin: async () => {
             throw new Error("should not launch a managed browser when immediate browser-session import succeeded");
         },
+        canPromptForManagedBrowserConfirmation: () => false,
         checkAuthDirect: async () => auth,
         log: (message) => {
             logs.push(message);
@@ -343,6 +376,7 @@ test("bootstrapAuthSessionWithDeps opens a watchable attached browser session be
             reachableCalls += 1;
             return candidates;
         },
+        describeDesktopBrowserReuseGap: async () => null,
         openUrlInAttachedBrowser: async () => {
             openAttachedCalls += 1;
             return true;
@@ -359,6 +393,7 @@ test("bootstrapAuthSessionWithDeps opens a watchable attached browser session be
         waitForManagedBrowserLogin: async () => {
             throw new Error("should not launch a managed browser when an attached browser is reachable");
         },
+        canPromptForManagedBrowserConfirmation: () => false,
         checkAuthDirect: async () => auth,
         log: (message) => {
             logs.push(message);
@@ -369,11 +404,11 @@ test("bootstrapAuthSessionWithDeps opens a watchable attached browser session be
     assert.equal(openDefaultCalls, 0);
     assert.equal(waitCalls, 1);
     assert.equal(waitTimeoutMs, 180_000);
-    assert.match(logs.join("\n"), /Opened DoorDash in the reusable browser session I'm watching/);
-    assert.match(logs.join("\n"), /Detected 1 reusable browser connection/);
+    assert.match(logs.join("\n"), /Opened DoorDash in the attachable browser session I'm watching/);
+    assert.match(logs.join("\n"), /Detected 1 attachable browser session/);
     assert.match(result.message, /saved it for direct API use/);
 });
-test("bootstrapAuthSessionWithDeps falls back to a managed browser login window when no reusable browser connection is discoverable", async () => {
+test("bootstrapAuthSessionWithDeps falls back to a managed browser login window and auto-completes when it can prove login", async () => {
     const auth = {
         success: true,
         isLoggedIn: true,
@@ -396,6 +431,7 @@ test("bootstrapAuthSessionWithDeps falls back to a managed browser login window
         markBrowserImportAttempted: () => { },
         getAttachedBrowserCdpCandidates: async () => ["http://127.0.0.1:9222"],
         getReachableCdpCandidates: async () => [],
+        describeDesktopBrowserReuseGap: async () => null,
         openUrlInAttachedBrowser: async () => false,
         openUrlInDefaultBrowser: async () => true,
         waitForAttachedBrowserSessionImport: async () => {
@@ -404,8 +440,13 @@ test("bootstrapAuthSessionWithDeps falls back to a managed browser login window
         },
         waitForManagedBrowserLogin: async () => {
             managedCalls += 1;
-            return auth;
+            return {
+                status: "completed",
+                completion: "automatic",
+                auth,
+            };
         },
+        canPromptForManagedBrowserConfirmation: () => true,
         checkAuthDirect: async () => auth,
         log: (message) => {
             logs.push(message);
@@ -414,10 +455,143 @@ test("bootstrapAuthSessionWithDeps falls back to a managed browser login window
     assert.equal(managedCalls, 1);
     assert.equal(attachedWaitCalls, 0);
     assert.match(logs.join("\n"), /temporary Chromium login window/);
-    assert.match(result.message, /temporary Chromium login window/);
+    assert.match(logs.join("\n"), /press Enter here to force an immediate recheck/i);
+    assert.match(result.message, /detected the signed-in session there automatically/i);
+    assert.equal(result.success, true);
+    assert.equal(result.isLoggedIn, true);
+});
+test("bootstrapAuthSessionWithDeps logs why an already-open desktop browser still is not reusable", async () => {
+    const auth = {
+        success: true,
+        isLoggedIn: true,
+        email: "user@example.com",
+        firstName: "Test",
+        lastName: "User",
+        consumerId: "consumer-1",
+        marketId: "market-1",
+        defaultAddress: null,
+        cookiesPath: "/tmp/cookies.json",
+        storageStatePath: "/tmp/storage-state.json",
+    };
+    const logs = [];
+    const result = await bootstrapAuthSessionWithDeps({
+        clearBlockedBrowserImport: async () => { },
+        checkPersistedAuth: async () => null,
+        importBrowserSessionIfAvailable: async () => false,
+        markBrowserImportAttempted: () => { },
+        getAttachedBrowserCdpCandidates: async () => [],
+        getReachableCdpCandidates: async () => [],
+        describeDesktopBrowserReuseGap: async () => "I can see Brave is already running on this desktop, but it is not exposing an attachable browser automation session right now.",
+        openUrlInAttachedBrowser: async () => false,
+        openUrlInDefaultBrowser: async () => true,
+        waitForAttachedBrowserSessionImport: async () => false,
+        waitForManagedBrowserLogin: async () => ({
+            status: "completed",
+            completion: "automatic",
+            auth,
+        }),
+        canPromptForManagedBrowserConfirmation: () => true,
+        checkAuthDirect: async () => auth,
+        log: (message) => {
+            logs.push(message);
+        },
+    });
+    assert.match(logs.join("\n"), /Brave is already running on this desktop/i);
+    assert.match(logs.join("\n"), /couldn't find an attachable browser session I can reuse/i);
     assert.equal(result.success, true);
     assert.equal(result.isLoggedIn, true);
 });
+test("bootstrapAuthSessionWithDeps restores an explicit Enter-style completion path for the managed browser fallback", async () => {
+    const auth = {
+        success: true,
+        isLoggedIn: true,
+        email: "user@example.com",
+        firstName: "Test",
+        lastName: "User",
+        consumerId: "consumer-1",
+        marketId: "market-1",
+        defaultAddress: null,
+        cookiesPath: "/tmp/cookies.json",
+        storageStatePath: "/tmp/storage-state.json",
+    };
+    const logs = [];
+    const result = await bootstrapAuthSessionWithDeps({
+        clearBlockedBrowserImport: async () => { },
+        checkPersistedAuth: async () => null,
+        importBrowserSessionIfAvailable: async () => false,
+        markBrowserImportAttempted: () => { },
+        getAttachedBrowserCdpCandidates: async () => [],
+        getReachableCdpCandidates: async () => [],
+        describeDesktopBrowserReuseGap: async () => null,
+        openUrlInAttachedBrowser: async () => false,
+        openUrlInDefaultBrowser: async () => true,
+        waitForAttachedBrowserSessionImport: async () => false,
+        waitForManagedBrowserLogin: async () => ({
+            status: "completed",
+            completion: "manual",
+            auth,
+        }),
+        canPromptForManagedBrowserConfirmation: () => true,
+        checkAuthDirect: async () => auth,
+        log: (message) => {
+            logs.push(message);
+        },
+    });
+    assert.match(logs.join("\n"), /press Enter here to force an immediate recheck/i);
+    assert.match(result.message, /After you pressed Enter to confirm the browser login was complete/i);
+    assert.equal(result.success, true);
+    assert.equal(result.isLoggedIn, true);
+});
+test("bootstrapAuthSessionWithDeps returns a bounded failure instead of a dead-end when managed browser auto-detection cannot prove login", async () => {
+    const auth = {
+        success: true,
+        isLoggedIn: false,
+        email: null,
+        firstName: null,
+        lastName: null,
+        consumerId: null,
+        marketId: null,
+        defaultAddress: null,
+        cookiesPath: "/tmp/cookies.json",
+        storageStatePath: "/tmp/storage-state.json",
+    };
+    let attachedWaitCalls = 0;
+    let attachedWaitTimeoutMs = 0;
+    const logs = [];
+    const result = await bootstrapAuthSessionWithDeps({
+        clearBlockedBrowserImport: async () => { },
+        checkPersistedAuth: async () => null,
+        importBrowserSessionIfAvailable: async () => false,
+        markBrowserImportAttempted: () => { },
+        getAttachedBrowserCdpCandidates: async () => ["http://127.0.0.1:9222"],
+        getReachableCdpCandidates: async () => [],
+        describeDesktopBrowserReuseGap: async () => null,
+        openUrlInAttachedBrowser: async () => false,
+        openUrlInDefaultBrowser: async () => true,
+        waitForAttachedBrowserSessionImport: async (input) => {
+            attachedWaitCalls += 1;
+            attachedWaitTimeoutMs = input.timeoutMs;
+            return false;
+        },
+        waitForManagedBrowserLogin: async () => ({
+            status: "timed-out",
+            auth,
+        }),
+        canPromptForManagedBrowserConfirmation: () => true,
+        checkAuthDirect: async () => auth,
+        log: (message) => {
+            logs.push(message);
+        },
+    });
+    assert.equal(attachedWaitCalls, 0);
+    assert.equal(attachedWaitTimeoutMs, 0);
+    assert.match(logs.join("\n"), /temporary Chromium login window/i);
+    assert.match(logs.join("\n"), /press Enter here to force an immediate recheck/i);
+    assert.equal(result.success, false);
+    assert.equal(result.isLoggedIn, false);
+    assert.match(result.message, /couldn't prove an authenticated DoorDash session/i);
+    assert.match(result.message, /press Enter sooner next time/i);
+});
 test("bootstrapAuthSessionWithDeps falls back to quick troubleshooting guidance when the managed browser login window cannot launch", async () => {
     const auth = {
         success: true,
@@ -441,6 +615,7 @@ test("bootstrapAuthSessionWithDeps falls back to quick troubleshooting guidance
         markBrowserImportAttempted: () => { },
         getAttachedBrowserCdpCandidates: async () => ["http://127.0.0.1:9222"],
         getReachableCdpCandidates: async () => [],
+        describeDesktopBrowserReuseGap: async () => null,
         openUrlInAttachedBrowser: async () => false,
         openUrlInDefaultBrowser: async () => true,
         waitForAttachedBrowserSessionImport: async (input) => {
@@ -448,7 +623,8 @@ test("bootstrapAuthSessionWithDeps falls back to quick troubleshooting guidance
             attachedWaitTimeoutMs = input.timeoutMs;
             return false;
         },
-        waitForManagedBrowserLogin: async () => null,
+        waitForManagedBrowserLogin: async () => ({ status: "launch-failed" }),
+        canPromptForManagedBrowserConfirmation: () => true,
         checkAuthDirect: async () => auth,
         log: (message) => {
             logs.push(message);
@@ -460,7 +636,53 @@ test("bootstrapAuthSessionWithDeps falls back to quick troubleshooting guidance
     assert.match(logs.join("\n"), /won't keep you waiting for the full login timeout/i);
     assert.equal(result.success, false);
     assert.equal(result.isLoggedIn, false);
-    assert.match(result.message, /still isn't exposing a reusable browser session/);
+    assert.match(result.message, /still isn't exposing an attachable browser session/);
+});
+test("bootstrapAuthSessionWithDeps clears the logout block before an explicit login reuses an attached browser session", async () => {
+    const auth = {
+        success: true,
+        isLoggedIn: true,
+        email: "user@example.com",
+        firstName: "Test",
+        lastName: "User",
+        consumerId: "consumer-1",
+        marketId: "market-1",
+        defaultAddress: null,
+        cookiesPath: "/tmp/cookies.json",
+        storageStatePath: "/tmp/storage-state.json",
+    };
+    let blocked = true;
+    let clearCalls = 0;
+    let importCalls = 0;
+    const result = await bootstrapAuthSessionWithDeps({
+        clearBlockedBrowserImport: async () => {
+            clearCalls += 1;
+            blocked = false;
+        },
+        checkPersistedAuth: async () => null,
+        importBrowserSessionIfAvailable: async () => {
+            importCalls += 1;
+            return blocked === false;
+        },
+        markBrowserImportAttempted: () => { },
+        getAttachedBrowserCdpCandidates: async () => [],
+        getReachableCdpCandidates: async () => [],
+        describeDesktopBrowserReuseGap: async () => null,
+        openUrlInAttachedBrowser: async () => false,
+        openUrlInDefaultBrowser: async () => false,
+        waitForAttachedBrowserSessionImport: async () => false,
+        waitForManagedBrowserLogin: async () => {
+            throw new Error("should not launch a managed browser when explicit login can immediately reuse an attached browser session");
+        },
+        canPromptForManagedBrowserConfirmation: () => false,
+        checkAuthDirect: async () => auth,
+        log: () => { },
+    });
+    assert.equal(clearCalls, 1);
+    assert.equal(importCalls, 1);
+    assert.equal(result.success, true);
+    assert.equal(result.isLoggedIn, true);
+    assert.match(result.message, /Imported an existing signed-in browser session/);
 });
 test("parseOptionSelectionsJson parses structured recursive option selections", () => {
     assert.deepEqual(parseOptionSelectionsJson('[{"groupId":"703393388","optionId":"4716032529"},{"groupId":"recommended_option_546935995","optionId":"546936011","children":[{"groupId":"780057412","optionId":"4702669757","quantity":2}]}]'), [

package/docs/examples.md

@@ -26,13 +26,13 @@ Check whether you already have reusable session state:
 doordash-cli auth-check
 ```
 
-If your saved local state is still valid, this exits immediately. Otherwise it tries to reuse a discoverable signed-in browser session, or opens a temporary Chromium login window and saves the session there:
+If your saved local state is still valid, this exits immediately. Otherwise it first tries to reuse same-machine Linux Brave/Chrome profile state, then a discoverable attachable signed-in browser session, and finally falls back to a temporary Chromium login window the CLI can watch directly. In that temporary-browser fallback, the CLI keeps checking automatically and you can also press Enter in the terminal to force an immediate recheck once the page shows you are signed in:
 
 ```bash
 doordash-cli login
 ```
 
-Reset saved session state when you want a clean logged-out start. This also disables automatic browser-session reuse until your next explicit `doordash-cli login`:
+Reset saved session state when you want a clean logged-out start. This also disables passive browser-session reuse until your next explicit `doordash-cli login`:
 
 ```bash
 doordash-cli logout

package/docs/install.md

@@ -60,14 +60,14 @@ doordash-cli search --query sushi
 
 ## Login and session reuse
 
-`doordash-cli login` reuses saved local auth when it is still valid. Otherwise it tries to import a discoverable signed-in browser session. If neither is available, it opens a temporary Chromium login window and saves the session there. If authentication still is not established, `login` exits non-zero.
+`doordash-cli login` reuses saved local auth when it is still valid. Otherwise it first tries to import signed-in same-machine Linux Brave/Chrome profile state, then falls back to a discoverable attachable signed-in browser session, and finally opens a temporary Chromium login window it can watch directly. If authentication still is not established, `login` exits non-zero.
 
-`doordash-cli auth-check` can also quietly import a discoverable signed-in browser session unless `doordash-cli logout` disabled that auto-reuse.
+`doordash-cli auth-check` can also quietly import same-machine Linux Brave/Chrome profile state or a discoverable attachable signed-in browser session unless `doordash-cli logout` disabled that auto-reuse.
 
-`doordash-cli logout` clears persisted cookies and stored browser state, then keeps automatic browser-session reuse disabled until you explicitly run `doordash-cli login` again.
+`doordash-cli logout` clears persisted cookies and stored browser state, then keeps passive browser-session reuse disabled until your next explicit `doordash-cli login` attempt.
 
 ## Browser-session troubleshooting
 
-Normally you should not need to think about browser plumbing. If `doordash-cli login` opens a temporary Chromium window, finish signing in there and let the CLI save the session.
+Normally you should not need to think about browser plumbing. If `doordash-cli login` opens a temporary Chromium window, finish signing in there and let the CLI save the session. The CLI keeps checking automatically, and if the page already shows you are signed in but the command has not finished yet, press Enter in the terminal to force an immediate recheck.
 
-If you expected reuse from another browser instead, make sure that browser exposes a compatible CDP endpoint, then rerun `doordash-cli login`.
+On Linux, the preferred reuse path is a signed-in local Brave or Google Chrome profile on the same machine, which does not need CDP/remote debugging. If that same-machine profile import is unavailable or not signed in, the next reuse path is an attachable browser automation session.

package/man/dd-cli.1

@@ -35,20 +35,25 @@ local browser, including the temporary login-window fallback.
 .TP
 .B auth-check
 Verify whether the saved session appears authenticated. This command can also
-quietly reuse or import an already-signed-in browser session when one is
-available, unless
+quietly reuse or import same-machine Linux Brave/Chrome browser profile state
+or an already-signed-in attachable browser session when one is available,
+unless
 .B logout
 explicitly disabled that auto-reuse.
 .TP
 .B login
-Reuse saved local auth when possible. Otherwise try to import a discoverable
-signed-in browser session, or open a temporary Chromium login window and save
-that session there. If authentication is still not established,
+Reuse saved local auth when possible. Otherwise first try to import signed-in
+same-machine Linux Brave/Chrome browser profile state, then a discoverable
+attachable signed-in browser session, and finally open a temporary Chromium
+login window and save that session there. The temporary-browser fallback
+auto-detects completion when it can, and also accepts an explicit Enter
+keypress in the terminal to force an immediate recheck once the page shows the
+user is signed in. If authentication is still not established,
 .B login
 exits non-zero.
 .TP
 .B logout
-Delete stored session material used by this CLI and disable automatic
+Delete stored session material used by this CLI and disable passive
 browser-session reuse until the next explicit
 .BR login .
 .TP
@@ -205,14 +210,18 @@ time, but the saved state is reused across runs unless cleared with
 .BR logout .
 After
 .BR logout ,
-automatic browser-session reuse stays disabled until the next explicit
+passive browser-session reuse stays disabled until the next explicit
 .BR login .
 .SH ENVIRONMENT
 .PP
 In the common case you should not need to configure browser plumbing manually.
-For attached-browser reuse, the CLI can probe compatible CDP URLs/ports and a
-few localhost defaults. If no reusable browser connection is discoverable,
-login falls back to a temporary Chromium window it can watch directly. See
+On Linux, the preferred browser-reuse path is a signed-in local Brave or Google
+Chrome profile on the same machine, which does not need CDP/remote debugging.
+For attached-browser reuse, the CLI can also probe compatible CDP URLs/ports
+and a few localhost defaults. If neither same-machine profile import nor an
+attachable browser session is discoverable, login falls back to a temporary
+Chromium window it can watch directly, with an explicit Enter-to-recheck
+fallback in the terminal if automatic detection is not yet convincing. See
 .I docs/install.md
 for setup and troubleshooting.
 .SH EXIT STATUS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doordash-cli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Cart-safe DoorDash CLI with direct API support for browse, read-only existing-order, and cart workflows.",
   "type": "module",
   "main": "dist/lib.js",