cjc0013/chatgpttrafficgate

ChatGPT Traffic Gate (Firefox MV3) — AutoPilot v2.2 (Safer)

This repo is not a dataset in the normal HF sense. It’s a place to host a Firefox MV3 extension that tries to keep ChatGPT usable when you have lots of tabs and/or very long conversations.

What it does (plain version)

• Blocks “load more history” pagination requests by default (the big ones that spike RAM / lag / churn).
• If history pagination is allowed, it can thin huge JSON responses (keeps the latest chunk and the needed ancestors for ChatGPT’s conversation mapping).
• Soft-caps the chat DOM by trimming old conversation turns out of the page:
  • visible tab: keep ~60 turns
  • hidden tab: keep ~20 turns
  • hidden for ~10 minutes: keep ~12 turns
• Keeps the session warm with low-overhead pings:
  • leader-only pings from the active tab
  • plus a low-frequency background event-page ping (single place, not per-tab)
• Adds a tiny UI pill so you can quickly toggle the gate or temporarily allow history.

This does not delete your chats on the server. It only changes what loads and what stays in the DOM.

---

Repo contents

You get the extension two ways:

• chat-traffic-gate-leader-softcap/ — unpacked extension folder
• chat-traffic-gate-leader-softcap.zip — the same thing, zipped

Inside the folder:

• manifest.json — MV3 manifest (Firefox)
• background.js — request gating + leader/follower role assignment + background alarm ping
• content/early-shield.js — briefly hides turns at page start, then unshields
• content/net-guard.js — patches fetch + XHR at document_start to block pagination and (when allowed) thin big JSON
• content/dom-softcap.js — trims old conversation turns out of the DOM (changes based on tab visibility)
• content/keepalive.js — leader-only keepalive pings + reconnect helper (reloads OFF by default)
• content/autopilot.js — visible-tab tuning (intent detection + adjusts keepalive/softcap if things look bad)
• content/traffic-ui.js — UI pill (“🚦 On/Off” + “Allow 10s”)

---

Install (fast / lazy)

Option A — load unpacked folder (recommended)

1. Download chat-traffic-gate-leader-softcap.zip from this repo and unzip it.
2. In Firefox, open: about:debugging#/runtime/this-firefox
3. Click Load Temporary Add-on…
4. Select the manifest.json inside the unzipped folder.

Temporary addons disappear when Firefox restarts (that’s normal).

Option B — use the unpacked folder in the repo

Same process as above, but download the folder contents and point Firefox at manifest.json.

---

How the “history gate” works

Background layer (webRequest)

background.js uses webRequestBlocking to cancel only true pagination requests:

• it looks for query params like cursor, before, offset>0, page>1, or backward direction markers
• it only applies to “history-like” endpoints
• it avoids blanket blocking (session and models endpoints are allow-listed)

Page layer (fetch/XHR patch)

content/net-guard.js runs at document_start and patches:

• window.fetch
• XMLHttpRequest

If a request is a paginated history load and you didn’t indicate intent:

• some list endpoints get a safe empty page JSON (soft-block)
• others get an AbortError / aborted XHR (hard-block)

Intent + temporary allow

The extension decides “intent” mostly from scroll behavior:

• near the top, or scrolling upward recently → intent = true
• otherwise intent = false

You can also force allow pagination for a short window:

• UI pill: Allow 10s
• programmatic: __chatTrafficGate.allowForMs(10000)

---

JSON thinning (what it actually does)

Only when a request is a paginated history request (the same pagination detection as above), it may thin JSON:

• if messages[] is huge → keep the newest ~60
• if items[] is huge → keep the newest ~60
• if ChatGPT’s mapping{} is huge → keep the newest ~60 nodes plus ancestors (and keep current_node / root when present)

Goal: reduce payload size while keeping the mapping structurally coherent.

---

DOM soft-cap (memory control)

The softcap script trims old turn nodes from the DOM using:

• selector: [data-testid^="conversation-turn-"]

It tries to keep the UI stable by:

• trimming in batches
• briefly hiding the container while trimming to reduce layout thrash
• unshielding the early CSS shield once the first trim completes

---

Keepalive + reconnect behavior

Leader-only pings

Only the active tab is intended to be “leader” and run keepalive pings. Background assigns roles and tells tabs to switch.

Endpoints it tries

It probes a small set and sticks with the first one that works, e.g.:

• /api/auth/session
• /backend-api/models
• /backend-api/conversations?offset=0&limit=1
• /favicon.ico
• /

Reconnect helper

It watches the DOM for text like “reconnecting / disconnected / network error” and tries:

• click buttons with text like “Retry / Reconnect / Try again”
• reload is OFF by default (AutoPilot may enable it temporarily if disconnects are bad)

---

UI controls

A small pill appears on the page:

• 🚦 On / Off: toggles history gating
• Allow 10s: allows pagination for 10 seconds in that tab

---

Dev / power-user globals

These are intentionally exposed by the scripts:

__chatTrafficGate.setEnabled(true|false)
__chatTrafficGate.setIntent(true|false)
__chatTrafficGate.allowForMs(10000)

__chatSoftCap.setConfig({ enabled: true, keep: 60, keepHidden: 20, keepDeepHidden: 12 })

__chatKeepalive.setMinutes(4)
__chatKeepalive.setAutoReconnect(true)
__chatKeepalive.setAllowReloads(false)
__chatKeepalive.reconnectNow()