From 7b9879c03702d825e7905fddae38faa29a055002 Mon Sep 17 00:00:00 2001 From: tomi Date: Tue, 17 Nov 2026 01:59:34 +0100 Subject: [PATCH 1/2] fix(browser): detect explicit ChatGPT Cloudflare challenges safely --- browser-companion/src/navigation.ts | 25 ++++++ .../tests/challenge-navigation.node.cjs | 85 +++++++++++++++++++ 2 files changed, 110 insertions(+) create mode 100644 browser-companion/tests/challenge-navigation.node.cjs diff --git a/browser-companion/src/navigation.ts b/browser-companion/src/navigation.ts index a406bcbe..0f98ffdd 100644 --- a/browser-companion/src/navigation.ts +++ b/browser-companion/src/navigation.ts @@ -213,6 +213,14 @@ export function isChatGptPage(value:string):boolean { try {return new URL(value).origin === "https://chatgpt.com";} catch {return false;} } +/** Cloudflare's documented, unambiguous challenge-response header. + * Do not infer challenges from ordinary HTTP 403/503 errors or page text. + * This checks responses only; it never solves challenges or exports cookies. + */ +export function isCloudflareChallengeHeader(value:string|null):boolean { + return value?.trim().toLowerCase()==="challenge"; +} + export async function navigatePage(page:Page,url:string,options:{signal?:AbortSignal;timeout?:number;reload?:boolean}={}):Promise { observeConversationRateLimits(page); options.signal?.throwIfAborted(); @@ -255,6 +263,23 @@ export async function navigatePage(page:Page,url:string,options:{signal?:AbortSi // navigation does not reliably cancel on an AbortSignal on every platform. const settings={waitUntil:"domcontentloaded" as const,timeout:options.timeout??15_000,signal:options.signal}; const response=options.reload?await page.reload(settings):await page.goto(target.href,settings); + // Some browser transports throw while reading headers. That must never + // mask an HTTP 429 diagnosis or bypass the existing cooldown. + let mitigation:string|null=null; + if(target.origin==="https://chatgpt.com" && response){ + try { mitigation=await response.headerValue?.("cf-mitigated")??null; } + catch { /* No reliable Cloudflare challenge evidence. */ } + } + if(isCloudflareChallengeHeader(mitigation)) { + // A challenged document is not evidence of a selector change or a + // successful transcript load. Preserve the shared recovery budget, and + // require manual verification in the original signed-in browser. + if(conversation)recordConversationUnavailable(page); + throw new BrowserCompanionError( + "ChatGPT returned a Cloudflare verification challenge; finish verification in the existing browser before retrying", + "external_interference", + ); + } if(response?.status()===429){ // A proxy or browser transport can fail to expose response headers. // Preserve the 429 diagnosis and the normal cooldown in that case. diff --git a/browser-companion/tests/challenge-navigation.node.cjs b/browser-companion/tests/challenge-navigation.node.cjs new file mode 100644 index 00000000..74df58e7 --- /dev/null +++ b/browser-companion/tests/challenge-navigation.node.cjs @@ -0,0 +1,85 @@ +// Offline regression coverage for the actual TypeScript navigation module +// on Windows machines without Bun. No Chrome, HTTP server, or account needed. +const {test} = require("node:test"); +const assert = require("node:assert/strict"); +const {readFileSync} = require("node:fs"); +const {join} = require("node:path"); +const ts = require("typescript"); + +class BrowserCompanionError extends Error { + constructor(message,code="failed") { + super(message); + this.code=code; + this.sendAccepted=false; + } +} +class ConversationCooldownError extends BrowserCompanionError { + constructor(availableAtMs) { + super("Conversation load cooldown","conversation_cooldown"); + this.availableAtMs=availableAtMs; + } +} +function loadNavigation(){ + const source=readFileSync(join(__dirname,"../src/navigation.ts"),"utf8"); + const output=ts.transpileModule(source,{compilerOptions:{ + target:ts.ScriptTarget.ES2022,module:ts.ModuleKind.CommonJS,esModuleInterop:true, + }}).outputText; + const mocks={ + "./errors":{BrowserCompanionError,ConversationCooldownError}, + "./protocol":{canonicalChatGptConversationUrl:url=>{ + const parsed=new URL(url); + return parsed.origin+parsed.pathname; + }}, + }; + const result={}; + new Function("require","exports","module",output)( + name=>mocks[name]??require(name),result,{exports:result}, + ); + return result; +} +class FakePage { + constructor(owner={},code=200,challenge=null) { + this.owner=owner; + this.code=code; + this.challenge=challenge; + this.current="https://chatgpt.com/"; + this.loads=[]; + } + context(){return this.owner;} + url(){return this.current;} + async goto(url){ + this.current=url; + this.loads.push(url); + return { + status:()=>this.code, + headerValue:async header=>header==="cf-mitigated"?this.challenge:null, + }; + } + async reload(){return this.goto(this.current);} +} + +test("ChatGPT Cloudflare challenges fail closed before repeating a conversation load",async()=>{ + const nav=loadNavigation(),owner={},page=new FakePage(owner,200,"challenge"); + await assert.rejects(nav.navigatePage(page,"https://chatgpt.com/c/a"),error=> + error.code==="external_interference"&&error.sendAccepted===false + &&error.message.includes("Cloudflare verification challenge")); + assert.deepEqual(page.loads,["https://chatgpt.com/c/a"]); + page.challenge=null; + await assert.rejects(nav.navigatePage(page,"https://chatgpt.com/c/b"),error=> + error.code==="conversation_cooldown"); + assert.equal(page.loads.length,1); + const another=new FakePage({},200); + await nav.navigatePage(another,"https://chatgpt.com/c/other-profile"); + assert.equal(another.loads.length,1); +}); + +test("403 alone does not mean Cloudflare; unrelated origins do not acquire ChatGPT holds",async()=>{ + const nav=loadNavigation(); + const ordinary=new FakePage({},403); + await nav.navigatePage(ordinary,"https://chatgpt.com/c/ordinary"); + const elsewhere=new FakePage({},403,"challenge"); + await nav.navigatePage(elsewhere,"https://example.com/protected"); + assert.equal(elsewhere.loads.length,1); + assert.equal(nav.isCloudflareChallengeHeader(" challenge "),true); + assert.equal(nav.isCloudflareChallengeHeader("bad-value"),false); +}); From 45aff414e3800c8eeedbb9e3b6ac614b87b7d1d2 Mon Sep 17 00:00:00 2001 From: tomi Date: Tue, 17 Nov 2026 01:59:36 +0100 Subject: [PATCH 2/2] fix(browser): retry stale pairing control once before Send --- browser-companion/src/pairing-model.ts | 15 +++- browser-companion/src/pairing-retry.ts | 24 +++++++ .../tests/pairing-retry.node.cjs | 71 +++++++++++++++++++ 3 files changed, 108 insertions(+), 2 deletions(-) create mode 100644 browser-companion/src/pairing-retry.ts create mode 100644 browser-companion/tests/pairing-retry.node.cjs diff --git a/browser-companion/src/pairing-model.ts b/browser-companion/src/pairing-model.ts index ab287a57..064f0217 100644 --- a/browser-companion/src/pairing-model.ts +++ b/browser-companion/src/pairing-model.ts @@ -8,6 +8,7 @@ import { requireChatGptEffortControl, activateChatGptEffortMenu, discoverChatGptEfforts, moveChatGptEffortSlider, readChatGptEffortSnapshot, readCurrentEffortLabel, } from "./session"; +import {retryPickerAfterControlTimeout} from "./pairing-retry"; export interface PairingMediumSelection { verify(signal: AbortSignal): Promise; @@ -23,8 +24,18 @@ export async function selectPairingMedium(page: Page, signal: AbortSignal): Prom async function selectPairingMediumInner(page: Page, signal: AbortSignal): Promise { const composer = await browserStage("composer_lookup","ChatGPT did not expose one editable pairing composer",()=>activeComposer(page, 10_000, signal)); - const control = await requireChatGptEffortControl(composer.locator("xpath=ancestor::form[1]"),signal); - const activate=(operationSignal=signal)=>browserStage("picker_open","ChatGPT did not open its pairing effort picker",()=>activateChatGptEffortMenu(page,control,{signal:operationSignal})); + let control = await requireChatGptEffortControl(composer.locator("xpath=ancestor::form[1]"),signal); + const originalUrl=page.url(); + const activate=(operationSignal=signal)=>browserStage("picker_open","ChatGPT did not open its pairing effort picker",()=>retryPickerAfterControlTimeout( + ()=>activateChatGptEffortMenu(page,control,{settleMs:5_000,signal:operationSignal}), + async()=>{ + // Only a definite pre-Send picker timeout permits one control reacquire. + // Re-verify the active composer; do not reuse a stale task's control. + const current=await activeComposer(page,5_000,operationSignal); + control=await requireChatGptEffortControl(current.locator("xpath=ancestor::form[1]"),operationSignal); + return activateChatGptEffortMenu(page,control,{settleMs:5_000,signal:operationSignal}); + },operationSignal,()=>page.url()===originalUrl, + )); const close=()=>control.press("Escape",{timeout:1_000}).catch(()=>{}); const checkedFamily = async (menu: Awaited>,operationSignal=signal) => { const {value:rows}=await withChatGptModelOptions(menu,()=>activate(operationSignal),async(_scope,rows)=>rows,{signal:operationSignal}); diff --git a/browser-companion/src/pairing-retry.ts b/browser-companion/src/pairing-retry.ts new file mode 100644 index 00000000..8dd0fd18 --- /dev/null +++ b/browser-companion/src/pairing-retry.ts @@ -0,0 +1,24 @@ +import {BrowserCompanionError} from "./errors"; + +/** One bounded pre-Send retry for a DOM-replaced model-picker control. + * No retries after a submitted message or for unknown/semantic failures. + */ +export async function retryPickerAfterControlTimeout( + attempt:()=>Promise, + reacquireAndRetry:()=>Promise, + signal:AbortSignal, + sameTarget:()=>boolean, +):Promise { + try {return await attempt();} + catch(error) { + if(signal.aborted || !(error instanceof Error) || error.name!=="TimeoutError")throw error; + signal.throwIfAborted(); + if(!sameTarget())throw new BrowserCompanionError( + "ChatGPT changed the pairing page while opening its effort picker", + "external_interference", + {cause:error}, + ); + // A retry may open the menu, but must never retry an actual Send. + return reacquireAndRetry(); + } +} diff --git a/browser-companion/tests/pairing-retry.node.cjs b/browser-companion/tests/pairing-retry.node.cjs new file mode 100644 index 00000000..aac5c003 --- /dev/null +++ b/browser-companion/tests/pairing-retry.node.cjs @@ -0,0 +1,71 @@ +const {test}=require("node:test"); +const assert=require("node:assert/strict"); +const {readFileSync}=require("node:fs"); +const {join}=require("node:path"); +const ts=require("typescript"); +class BrowserCompanionError extends Error { + constructor(message,code,options){super(message);this.code=code;this.sendAccepted=false;this.cause=options?.cause;} +} +const js=ts.transpileModule( + readFileSync(join(__dirname,"../src/pairing-retry.ts"),"utf8"), + {compilerOptions:{target:ts.ScriptTarget.ES2022,module:ts.ModuleKind.CommonJS}}, +).outputText; +const scope={exports:{}}; +new Function("require","exports","module",js)( + name=>name==="./errors"?{BrowserCompanionError}:require(name),scope.exports,scope, +); +const {retryPickerAfterControlTimeout}=scope.exports; +function timeout(){const error=new Error("locator went stale");error.name="TimeoutError";return error;} + +test("stale picker gets exactly one reacquire, and never sends",async()=>{ + let attempts=0,reacquires=0,sends=0; + const result=await retryPickerAfterControlTimeout( + async()=>{attempts++;throw timeout();}, + async()=>{reacquires++;return "new-control";}, + new AbortController().signal,()=>true, + ); + assert.equal(result,"new-control"); + assert.equal(attempts,1); + assert.equal(reacquires,1); + assert.equal(sends,0); +}); + +test("unrelated errors and aborted attempts do not retry",async()=>{ + for(const reason of [new Error("selector drift"),new BrowserCompanionError("another page","external_interference")]){ + let retries=0; + await assert.rejects(retryPickerAfterControlTimeout( + async()=>{throw reason;}, + async()=>{retries++;}, + new AbortController().signal,()=>true, + ),error=>error===reason); + assert.equal(retries,0); + } + const controller=new AbortController();controller.abort(); + let retries=0; + await assert.rejects(retryPickerAfterControlTimeout( + async()=>{throw timeout();}, + async()=>{retries++;}, + controller.signal,()=>true, + )); + assert.equal(retries,0); +}); + +test("changed conversation fails closed without reacquiring",async()=>{ + let reacquires=0; + await assert.rejects(retryPickerAfterControlTimeout( + async()=>{throw timeout();}, + async()=>{reacquires++;}, + new AbortController().signal,()=>false, + ),error=>error.code==="external_interference"&&error.sendAccepted===false); + assert.equal(reacquires,0); +}); + +test("reacquire is bounded and a second timeout is not retried",async()=>{ + let reacquires=0; + await assert.rejects(retryPickerAfterControlTimeout( + async()=>{throw timeout();}, + async()=>{reacquires++;throw timeout();}, + new AbortController().signal,()=>true, + ),error=>error.name==="TimeoutError"); + assert.equal(reacquires,1); +});