Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
25 changes: 25 additions & 0 deletions browser-companion/src/navigation.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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<void> {
observeConversationRateLimits(page);
options.signal?.throwIfAborted();
Expand Down Expand Up @@ -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.
Expand Down
15 changes: 13 additions & 2 deletions browser-companion/src/pairing-model.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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<void>;
Expand All @@ -23,8 +24,18 @@ export async function selectPairingMedium(page: Page, signal: AbortSignal): Prom

async function selectPairingMediumInner(page: Page, signal: AbortSignal): Promise<PairingMediumSelection> {
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<ReturnType<typeof activateChatGptEffortMenu>>,operationSignal=signal) => {
const {value:rows}=await withChatGptModelOptions(menu,()=>activate(operationSignal),async(_scope,rows)=>rows,{signal:operationSignal});
Expand Down
24 changes: 24 additions & 0 deletions browser-companion/src/pairing-retry.ts
Original file line number Diff line number Diff line change
@@ -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<T>(
attempt:()=>Promise<T>,
reacquireAndRetry:()=>Promise<T>,
signal:AbortSignal,
sameTarget:()=>boolean,
):Promise<T> {
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();
}
}
85 changes: 85 additions & 0 deletions browser-companion/tests/challenge-navigation.node.cjs
Original file line number Diff line number Diff line change
@@ -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);
});
71 changes: 71 additions & 0 deletions browser-companion/tests/pairing-retry.node.cjs
Original file line number Diff line number Diff line change
@@ -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);
});
Loading