fix(browser): make orca cookie delete remove only the named cookie (#42279)

agent-browser's `cookies clear` ignores --name/--domain and wipes the
whole profile cookie jar, so `orca cookie delete` signed users out of
every site. Delete through the guest debugger instead: list cookies with
Network.getAllCookies, match by name and host (host-only, dot-prefixed,
and parent-domain cookies for --url / tab URL), and call
Network.deleteCookies per match, passing CHIPS partition keys back.
Report deleted:false when nothing matched, and reject tab URLs without a
cookie host (about:, file:, data:) asking for --domain or --url. The
external Chromium provider no longer maps cookie delete to the
jar-wiping agent-browser command.

Fixes #42229

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Neil
2026-11-13 21:23:03 -08:00
committed by GitHub
co-authored by Claude Opus 5.5
parent c7ebf68173
commit 7cef794a4a
10 changed files with 231 additions and 52 deletions
+3 -1
View File
@@ -89,6 +89,8 @@ export const BROWSER_COOKIE_HANDLERS: Record<string, CommandHandler> = {
}
Object.assign(params, await getBrowserCommandTarget(flags, cwd, client))
const result = await client.call<BrowserCookieDeleteResult>('browser.cookie.delete', params)
printResult(result, json, () => `Cookie "${name}" deleted`)
printResult(result, json, (v) =>
v.deleted === false ? `No cookie "${name}" found` : `Cookie "${name}" deleted`
)
}
}
@@ -19,6 +19,7 @@ import {
} from './protocol/agent-browser-passthrough-arguments'
import { AgentBrowserBridgeInteractionCommands } from './commands/agent-browser-bridge-interaction-commands'
import { sendGuestCdpCommand } from '../cdp/debugger/guest-cdp-command'
import { deleteCookieByName } from '../cookies/browser-cookie-delete-by-name'
import {
toBrowserConsoleResult,
toBrowserNetworkLogResult,
@@ -71,21 +72,20 @@ export class AgentBrowserBridge extends AgentBrowserBridgeInteractionCommands {
}
async cookieDelete(
name?: string,
name: string,
domain?: string,
_url?: string,
url?: string,
worktreeId?: string,
browserPageId?: string
): Promise<BrowserCookieDeleteResult> {
return this.enqueueTargetedCommand(worktreeId, browserPageId, async (sessionName) => {
const args = ['cookies', 'clear']
if (name) {
args.push('--name', name)
}
if (domain) {
args.push('--domain', domain)
}
return (await this.execAgentBrowser(sessionName, args)) as BrowserCookieDeleteResult
return this.enqueueTargetedCommand(worktreeId, browserPageId, async (_sessionName, target) => {
const wc = this.requireTargetWebContents(target)
// agent-browser's `cookies clear` ignores filters and wipes the profile's whole cookie jar.
return deleteCookieByName((method, params) => sendGuestCdpCommand(wc, method, params), name, {
domain,
url,
pageUrl: wc.getURL()
})
})
}
@@ -63,7 +63,8 @@ import {
mockBrowserManager,
mockWebContents,
overrideBridgeWebContentsLookup,
resetAgentBrowserBridgeMocks
resetAgentBrowserBridgeMocks,
succeedRecordingAgentBrowserSpawns
} from '../testing/agent-browser-bridge-test-harness'
overrideBridgeWebContentsLookup(AgentBrowserBridge.prototype, webContentsFromIdMock)
@@ -106,4 +107,26 @@ describe('AgentBrowserBridge', () => {
expect.objectContaining({ expression: 'sideEffect()' })
)
})
it('deletes the named cookie through the guest debugger instead of clearing the profile', async () => {
const spawns = succeedRecordingAgentBrowserSpawns(execFileMock, stdinWrites, { cleared: true })
const wc = mockWebContents(100, 'https://www.example.com/app')
wc.debugger.sendCommand.mockImplementation(async (method) =>
method === 'Network.getAllCookies'
? { cookies: [{ name: 'sid', domain: '.example.com', path: '/' }] }
: {}
)
webContentsFromIdMock.mockReturnValue(wc)
await expect(bridge.cookieDelete('sid')).resolves.toEqual({ deleted: true })
expect(wc.debugger.sendCommand).toHaveBeenCalledWith('Network.deleteCookies', {
name: 'sid',
domain: '.example.com',
path: '/'
})
expect(spawns.map(({ command }) => command)).not.toContainEqual(
expect.arrayContaining(['cookies', 'clear'])
)
})
})
@@ -16,6 +16,7 @@ import type {
BrowserViewportResult
} from '../../../../shared/browser/runtime/runtime-browser-contracts'
import type { CdpCommandSender } from '../debugger/cdp-command-sender'
import { deleteCookieByName } from '../../cookies/browser-cookie-delete-by-name'
type ActiveCdpContext = {
guest: WebContents
@@ -85,24 +86,9 @@ export class CdpAuxiliaryCommands {
}
cookieDelete(name: string, domain?: string, url?: string): Promise<BrowserCookieDeleteResult> {
return this.host.run(async ({ sender }) => {
const params: Record<string, unknown> = { name }
if (domain) {
params.domain = domain
}
if (url) {
params.url = url
}
if (!domain && !url) {
const { result } = (await sender('Runtime.evaluate', {
expression: 'location.href',
returnByValue: true
})) as { result: { value: string } }
params.url = result.value
}
await sender('Network.deleteCookies', params)
return { deleted: true }
})
return this.host.run(({ guest, sender }) =>
deleteCookieByName(sender, name, { domain, url, pageUrl: guest.getURL() })
)
}
setViewport(
@@ -17,3 +17,12 @@ export type CdpCookie = {
partitionKey?: CdpCookiePartitionKey | null
partitionKeyOpaque?: boolean
}
/** Reads the `cookies` array from a `Network.getAllCookies` reply. */
export function cdpCookiesFromCommand(value: unknown): CdpCookie[] {
if (typeof value !== 'object' || value === null || !('cookies' in value)) {
return []
}
const cookies = value.cookies
return Array.isArray(cookies) ? cookies : []
}
@@ -13,7 +13,7 @@ import type {
} from './storage/cookie-store-contracts'
import { restoreEveryCookieIdentity } from './browser-cookie-identity-restore'
import { normalizeCookiePartitionSite } from './sources/browser-cookie-source-partition'
import type { CdpCookie } from './browser-cdp-cookie'
import { cdpCookiesFromCommand, type CdpCookie } from './browser-cdp-cookie'
function cdpSameSite(sameSite: Cookie['sameSite']): 'Strict' | 'Lax' | 'None' | undefined {
if (sameSite === 'strict') {
@@ -152,14 +152,6 @@ export function cdpSetCookieParamsFromIdentity(
}
}
function cdpCookiesFromCommand(value: unknown): CdpCookie[] {
if (typeof value !== 'object' || value === null || !('cookies' in value)) {
return []
}
const cookies = value.cookies
return Array.isArray(cookies) ? cookies : []
}
function cdpSetCookieSucceeded(value: unknown): boolean {
if (typeof value !== 'object' || value === null || !('success' in value)) {
return true
@@ -0,0 +1,99 @@
import { describe, expect, it } from 'vitest'
import { deleteCookieByName } from './browser-cookie-delete-by-name'
const partitionKey = { topLevelSite: 'https://example.org', hasCrossSiteAncestor: true }
const COOKIES = [
{ name: 'sid', domain: '.example.com', path: '/' },
{ name: 'sid', domain: 'example.com', path: '/account' },
{ name: 'sid', domain: 'example.com', path: '/', partitionKey },
{ name: 'sid', domain: 'www.example.com', path: '/' },
{ name: 'sid', domain: 'example.net', path: '/' },
{ name: 'sid', domain: 'example.com', path: '/', partitionKeyOpaque: true },
{ name: 'keep', domain: '.example.com', path: '/' }
]
async function deleteSid(target: Parameters<typeof deleteCookieByName>[2]) {
const deletes: Record<string, unknown>[] = []
const result = await deleteCookieByName(
async (method, params) => {
if (method === 'Network.getAllCookies') {
return { cookies: COOKIES }
}
deletes.push({ method, ...params })
return {}
},
'sid',
target
)
return { result, deletes }
}
describe('deleteCookieByName', () => {
it('deletes host-only and dot-prefixed cookies on the given domain', async () => {
const { result, deletes } = await deleteSid({
domain: '.Example.COM',
pageUrl: 'https://ignored.test/'
})
expect(result).toEqual({ deleted: true })
expect(deletes).toEqual([
{ method: 'Network.deleteCookies', name: 'sid', domain: '.example.com', path: '/' },
{ method: 'Network.deleteCookies', name: 'sid', domain: 'example.com', path: '/account' },
{
method: 'Network.deleteCookies',
name: 'sid',
domain: 'example.com',
path: '/',
partitionKey
}
])
})
it('deletes cookies the URL host would receive, including parent-domain cookies', async () => {
const { deletes } = await deleteSid({
url: 'https://www.example.com/app',
pageUrl: 'https://ignored.test/'
})
expect(deletes.map(({ domain }) => domain)).toEqual(['.example.com', 'www.example.com'])
})
it('reports nothing deleted when no cookie matches', async () => {
await expect(
deleteSid({ domain: 'example.org', pageUrl: 'https://ignored.test/' })
).resolves.toEqual({
result: { deleted: false },
deletes: []
})
})
it('rejects a domain or URL it cannot match cookies against', async () => {
await expect(
deleteSid({ domain: 'localhost:3000', pageUrl: 'https://ignored.test/' })
).rejects.toMatchObject({
code: 'invalid_argument'
})
await expect(
deleteSid({ url: 'example.com', pageUrl: 'https://ignored.test/' })
).rejects.toMatchObject({
code: 'invalid_argument'
})
})
it('falls back to the tab URL and asks for --domain or --url when it has no cookie host', async () => {
const { deletes } = await deleteSid({ pageUrl: 'https://www.example.com/app' })
expect(deletes.map(({ domain }) => domain)).toEqual(['.example.com', 'www.example.com'])
for (const pageUrl of [
'about:blank',
'file:///tmp/a.html',
'data:text/html,hi',
'chrome-error://chromewebdata/'
]) {
await expect(deleteSid({ pageUrl })).rejects.toMatchObject({
code: 'invalid_argument',
message: expect.stringContaining('pass --domain or --url')
})
}
})
})
@@ -0,0 +1,72 @@
import type { BrowserCookieDeleteResult } from '../../../shared/browser/runtime/runtime-browser-contracts'
import { BrowserError } from '../browser-error'
import type { CdpCommandSender } from '../cdp/debugger/cdp-command-sender'
import { cdpCookiesFromCommand } from './browser-cdp-cookie'
import { normalizeCookieDomain } from './policy/cookie-domain'
type CookieDeleteTarget = {
domain?: string
url?: string
/** The tab's URL, used when neither `domain` nor `url` is given. */
pageUrl: string
}
function cookieDeleteHost({ domain, url, pageUrl }: CookieDeleteTarget): string {
if (domain) {
const host = normalizeCookieDomain(domain)
if (!host) {
throw new BrowserError('invalid_argument', `Invalid cookie domain "${domain}"`)
}
return host
}
if (url) {
const host = URL.parse(url)?.hostname
if (!host) {
throw new BrowserError('invalid_argument', `Invalid cookie URL "${url}"`)
}
return host
}
const page = URL.parse(pageUrl)
if (!page?.hostname || (page.protocol !== 'http:' && page.protocol !== 'https:')) {
throw new BrowserError(
'invalid_argument',
`The tab is on "${pageUrl}", which has no cookie domain; pass --domain or --url`
)
}
return page.hostname
}
/**
* Deletes cookies named `name` stored on `domain` (host-only or dot-prefixed), or else every cookie
* of that name the `url` (or tab) host would receive, at any path. Network.deleteCookies alone
* matches only the exact stored domain, which would leave `Domain=`-scoped cookies (stored as
* `.example.com`).
*/
export async function deleteCookieByName(
sender: CdpCommandSender,
name: string,
target: CookieDeleteTarget
): Promise<BrowserCookieDeleteResult> {
const host = cookieDeleteHost(target)
const matches = cdpCookiesFromCommand(await sender('Network.getAllCookies')).filter(
({ name: cookieName, domain: cookieDomain = '', partitionKeyOpaque }) =>
cookieName === name &&
// Opaque partition keys cannot be passed back to Network.deleteCookies.
!partitionKeyOpaque &&
(cookieDomain === host ||
cookieDomain === `.${host}` ||
(!target.domain && cookieDomain.startsWith('.') && host.endsWith(cookieDomain)))
)
await Promise.all(
matches.map((cookie) =>
sender('Network.deleteCookies', {
name,
domain: cookie.domain,
path: cookie.path,
// Partitioned (CHIPS) cookies are only deleted when their partition key is passed back.
...(cookie.partitionKey ? { partitionKey: cookie.partitionKey } : {})
})
)
)
return { deleted: matches.length > 0 }
}
@@ -0,0 +1,8 @@
import { describe, expect, it } from 'vitest'
import { externalChromiumCommandArguments } from './external-chromium-command-arguments'
describe('externalChromiumCommandArguments', () => {
it('leaves cookie delete unmapped because agent-browser can only clear the whole jar', () => {
expect(externalChromiumCommandArguments('browserCookieDelete', { name: 'sid' })).toBeNull()
})
})
@@ -41,16 +41,6 @@ function cookieSetArguments(params: Record<string, unknown>): string[] {
}
return args
}
function cookieDeleteArguments(params: Record<string, unknown>): string[] {
const args = ['cookies', 'clear']
if (params.name) {
args.push('--name', String(params.name))
}
if (params.domain) {
args.push('--domain', String(params.domain))
}
return args
}
export function externalChromiumCommandArguments(
method: string,
@@ -139,8 +129,6 @@ export function externalChromiumCommandArguments(
return ['highlight', text('selector')]
case 'browserCookieGet':
return ['cookies', 'get']
case 'browserCookieDelete':
return cookieDeleteArguments(params)
case 'browserSetGeolocation':
return ['set', 'geo', text('latitude'), text('longitude')]
case 'browserInterceptDisable':