diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 2f13902..8810201 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -32,3 +32,26 @@ jobs: if: runner.os == 'Windows' shell: pwsh run: ./tools/test-update-metadata.ps1 + - name: Run browser identity and live interception audits + if: runner.os == 'Windows' + shell: pwsh + run: | + if (-not (Test-Path ./node_modules/electron/dist/electron.exe)) { + $env:ELECTRON_SKIP_BINARY_DOWNLOAD = '' + node ./node_modules/electron/install.js + if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } + } + $executable = (Resolve-Path ./node_modules/electron/dist/electron.exe).Path + $app = Start-Process -FilePath $executable -ArgumentList '.', '--fathi-e2e', '--fathi-identity-audit', '--fathi-intercept-audit' -PassThru -Wait + Get-Content e2e-result.txt + if ($app.ExitCode -ne 0) { exit $app.ExitCode } + - name: Preserve browser audit reports + if: always() && runner.os == 'Windows' + uses: actions/upload-artifact@v4 + with: + name: browser-audit-windows + path: | + e2e-report.json + e2e-result.txt + e2e-*.png + if-no-files-found: ignore diff --git a/CHANGELOG.md b/CHANGELOG.md index fb23ced..f74e8f4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,12 @@ ## Unreleased +- Keep the interception queue visible while editing, preserve per-request + drafts and advance selection after Forward or Drop. +- Apply all four rule targets to live traffic, including body rules with + Intercept off; preserve repeated headers and enforce worker timeouts. +- Send Repeat through the source tab session and report redirects without + automatically following them. - Fall back to public GitHub release metadata when the API is unavailable; command-line updates still require GitHub's SHA-256 digest before replacing files. - Audit profile entropy, canvas/audio consistency, timezone semantics, native diff --git a/README.md b/README.md index a4e10b6..f05720f 100644 --- a/README.md +++ b/README.md @@ -10,6 +10,7 @@ Built with Electron and Chromium for Windows, Linux, and macOS. [Download](https://github.com/iMumd/fathi-browser/releases/latest) · [Research guide](docs/research-workspace.md) · [Identity audit](docs/identity-audit.md) · +[Interception and rules](docs/interception-and-rules.md) · [Contribute](CONTRIBUTING.md) · [Changelog](CHANGELOG.md) @@ -35,6 +36,12 @@ still **1.0.2**. Updating a released installation does not install unreleased co 5. Pin one response as a baseline, open another, and select **Compare**. 6. Export only the filtered records. Use **Redacted JSON** when sharing context. +Intercept keeps the pending queue visible while you edit a request. Switch +between requests without losing drafts; Forward and Drop stay at the top. +Live rules cover header values and supported text bodies, including when +manual interception is off. See the [rule limits](docs/interception-and-rules.md) +before relying on a transformation. + Research tools do not automatically crawl, scan, or attack targets. Passive notes do not issue extra requests and are not confirmed vulnerability reports. JWT inspection decodes claims; it does not verify their signature. diff --git a/docs/interception-and-rules.md b/docs/interception-and-rules.md new file mode 100644 index 0000000..66767fd --- /dev/null +++ b/docs/interception-and-rules.md @@ -0,0 +1,89 @@ +# Interception and live rules + +Status: unreleased source changes after 1.0.2. + +## Queue and editor + +With Intercept enabled, the first matching request opens automatically. The +pending queue stays visible above the editor and scrolls independently. Select +another request without forwarding the current one; URL, method, header rows, +body and selected editor view are retained as an in-memory draft. + +Forward, Drop and Repeat stay above the editor and remain visible while it +scrolls. Forward sends the selected edits. Drop aborts the selected request +without sending it to the target. Resolving a request selects the next queued +request. Forward all submits the current queue snapshot with saved drafts. +Failed sends retain the pause rather than removing it from the UI. + +The interceptor filter affects future pause decisions. It does not hide +already-paused requests. Pauses from different tabs have distinct IDs, even if +Chromium reuses a Fetch request ID. Closed/detached targets and expired pauses +are removed from the UI. Drafts are never written to disk. + +Safety limits: at most 80 pending requests and a two-minute pause deadline. +Timeout or turning Intercept off forwards the backend's initially rewritten +request, not an unsent frontend draft. Use Forward or Forward all to explicitly +send edits. This avoids leaving a tab frozen indefinitely. + +## Rules in real traffic + +Request headers, request bodies, response headers and response bodies are +tested against a local HTTP server, not just through the preview UI. Header +rules are applied once through the session request hooks. Body rules use the +existing shared Fetch debugger connection and remain enabled when manual +interception is off. Response pauses are recognized from the actual +`Fetch.requestPaused` event with response metadata. + +- Header rules match **header values**, not entire raw header lines or names. + Use the structured interception editor to rename, add or remove headers. +- Rules run in their saved order. Disabled rules do not run. +- Plain-text replacement treats `$1` and other dollar sequences literally. + Regex replacement supports JavaScript capture-group syntax. +- Repeated response headers, especially Set-Cookie, remain separate values. +- Body changes update length/encoding metadata and remove stale entity hashes. + Modified response text is delivered as UTF-8. CSP and application-level + integrity protections are not silently removed. +- The manual request editor starts with request-body rule output. Forward + sends that output or your edits once, rather than applying it again. + +## Bounds and unsupported cases + +Live processing uses at most two worker threads, a queue of 32 waiting jobs, +and a 1.5-second execution timeout per job. Up to 100 rules can be saved; match +patterns are limited to 4,096 characters and replacements to 65,536. Invalid +regexes are rejected on save. + +Body-rule input is limited to 64 KiB of UTF-8 text. Large, binary or unavailable +upload bodies, HEAD responses, redirects, empty responses and partial-content +responses are not rewritten. Only supported textual response MIME types are +processed. CDP may obtain an unknown-length response before the decoded size +can be checked; this is not a streaming or general binary rewrite engine. + +If a worker times out, the queue is full, or input cannot be processed safely, +traffic continues unchanged and the UI reports a rate-limited warning. Do not +use Match and Replace as an enforced data-loss prevention or network-security +boundary. DevTools can detach the shared debugger and disrupt body rewriting; +closing it reconfigures the Fetch hooks. + +## Repeat + +Repeat sends the editor's current request through its source tab's session, +including that session's proxy, cookies, identity headers and pinned CA trust. +There is no unconfigured direct-network fallback. It has a 15-second timeout +and a 512 KiB response preview cap. Redirects are reported but not followed +automatically. Request-body edits already shown in the editor are sent as-is. + +## Reproduce the checks + +```bash +npm test +npx electron . --fathi-e2e --fathi-identity-audit --fathi-intercept-audit +``` + +The local live-rule fixture checks all four targets with non-idempotent plain +replacements and regex capture groups, both automatic processing and manual +forwarding, separate cookies, source-session replay, redirects, and a +three-request queue with saved drafts and dropped requests. Unit tests also +exercise worker timeouts, equal IDs across tabs, failed continuation and UTF-8 +response-length correction. Passing these cases is not a promise that every +protocol, site, payload size, or external network condition is supported. diff --git a/package.json b/package.json index bb96463..2bc0ca6 100644 --- a/package.json +++ b/package.json @@ -25,7 +25,7 @@ "license": "MIT", "main": "src/main/main.js", "scripts": { - "test": "node tools/check-syntax.js && node --test tools/test-research.js tools/test-network.js tools/test-identity.js tools/test-certificate.js tools/test-update-fallback.js && node tools/test-rules.js", + "test": "node tools/check-syntax.js && node --test tools/test-research.js tools/test-network.js tools/test-identity.js tools/test-certificate.js tools/test-update-fallback.js tools/test-intercept.js && node tools/test-rules.js", "start": "electron .", "icons": "node tools/make-icons.js && node tools/make-installer-art.js", "dist:win": "electron-builder --win nsis portable --x64 --publish never", diff --git a/src/main/e2e.js b/src/main/e2e.js index 5f51dd8..31454c4 100644 --- a/src/main/e2e.js +++ b/src/main/e2e.js @@ -153,6 +153,11 @@ async function run(win) { JSON.stringify(about)); /* ---- 3. second tab gets a different partition */ + if (process.argv.includes('--fathi-intercept-audit')) { + trace('live interception and rule audit'); + const checks = await require('./intercept-checks').run(ui); + for (const check of checks) add(check.name, check.pass, check.detail); + } if (process.argv.includes('--fathi-identity-audit')) { trace('identity isolation audit'); const checks = await require('./identity-checks').run(ui); @@ -313,7 +318,7 @@ async function run(win) { const topActions = await ui.executeJavaScript(`(async () => { devOpen('intercept'); await ixOpenItem(ix.items[0].id); ixRenderHeaderRows(Object.fromEntries(Array.from({ length: 30 }, (_, i) => ['X-Test-' + i, 'test value']))); - const scroller = document.querySelector('#pane-intercept .ix-body'); + const scroller = document.getElementById('ix-detail'); const bar = document.querySelector('.ix-action-bar'); const aboveEditor = bar.getBoundingClientRect().bottom <= document.getElementById('ix-url').getBoundingClientRect().top; scroller.scrollTop = 300; diff --git a/src/main/intercept-checks.js b/src/main/intercept-checks.js new file mode 100644 index 0000000..6c8e18f --- /dev/null +++ b/src/main/intercept-checks.js @@ -0,0 +1,101 @@ +'use strict'; +const http = require('node:http'); +const { webContents } = require('electron'); +const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); +async function run(ui) { + const checks = []; let tab; const received = []; + const add = (name, pass, detail = '') => checks.push({ name, pass: !!pass, detail: typeof detail === 'string' ? detail : JSON.stringify(detail) }); + const server = http.createServer((req, res) => { + if (req.url === '/redirect') { res.writeHead(302, { Location: '/off-target' }); res.end(); return; } + if (req.url === '/') { res.setHeader('Content-Type', 'text/html'); res.end('Local rule fixture'); return; } + let body = ''; req.on('data', (chunk) => { body += chunk; }); + req.on('end', () => { + received.push({ url: req.url, body, header: req.headers['x-rule-probe'], cookie: req.headers.cookie || '' }); + res.setHeader('Content-Type', 'application/json; charset=utf-8'); + res.setHeader('X-Response-Probe', 'response-token'); + res.setHeader('Set-Cookie', ['first=one; Path=/', 'second=two; Path=/']); + res.end(JSON.stringify({ body, header: req.headers['x-rule-probe'] || '', marker: 'response-body' })); + }); + }); + await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve)); + const url = `http://127.0.0.1:${server.address().port}/`; + const old = await ui.executeJavaScript('(async () => (await window.api.rules.list()).rules)()'); + let wc; + try { + await ui.executeJavaScript('window.api.intercept.set(false)'); + tab = await ui.executeJavaScript(`(async () => { const t = await createTab({ url: ${JSON.stringify(url)} }); return { id: t.id }; })()`); + for (let i = 0; i < 80; i++) { + const id = await ui.executeJavaScript(`(() => { try { return state.tabs.find(t => t.id === ${JSON.stringify(tab.id)}).wv.getWebContentsId(); } catch { return null; } })()`); + wc = id && webContents.fromId(id); + if (wc && await wc.executeJavaScript('!!window.__rulesFixture').catch(() => false)) break; + await delay(100); + } + const cases = [ + { regex: false, matchRequestBody: 'request-body', matchResponseBody: 'response-body', matchRequestHeader: 'request-token', matchResponseHeader: 'response-token', replacement: (value) => value + '-once', body: 'request-body-once', requestHeader: 'request-token-once', responseHeader: 'response-token-once', responseBody: 'response-body-once' }, + { regex: true, matchRequestBody: '(request)-(body)', matchResponseBody: '(response)-(body)', matchRequestHeader: '(request)-(token)', matchResponseHeader: '(response)-(token)', replacement: () => '$2/$1', body: 'body/request', requestHeader: 'token/request', responseHeader: 'token/response', responseBody: 'body/response' } + ]; + for (const scenario of cases) { + const targets = ['requestBody', 'responseBody', 'requestHeader', 'responseHeader']; + const list = targets.map((target, i) => { + const match = scenario['match' + target[0].toUpperCase() + target.slice(1)]; + return { id: 'live-' + i, enabled: true, target, match, replace: scenario.replacement(match), regex: scenario.regex }; + }); + const saved = await ui.executeJavaScript(`window.api.rules.save(${JSON.stringify(list)})`); + if (!saved.ok) throw new Error(saved.error); + const result = await wc.executeJavaScript(`(async () => { const r = await fetch('/echo', { method: 'POST', headers: { 'X-Rule-Probe': 'request-token', 'Content-Type': 'text/plain' }, body: 'request-body' }); return { status: r.status, header: r.headers.get('x-response-probe'), data: await r.json(), cookies: document.cookie }; })()`); + add(`live rules: all four ${scenario.regex ? 'regex/capture' : 'plain-text'} targets apply once while Intercept is off`, result.data.body === scenario.body && result.data.header === scenario.requestHeader && result.header === scenario.responseHeader && result.data.marker === scenario.responseBody, result); + add('live rules: response header rewriting preserves separate Set-Cookie fields', result.cookies.includes('first=one') && result.cookies.includes('second=two'), result.cookies); + } + const manualRules = ['requestBody', 'responseBody', 'requestHeader', 'responseHeader'].map((target, i) => { + const match = cases[0]['match' + target[0].toUpperCase() + target.slice(1)]; + return { id: 'manual-' + i, enabled: true, target, match, replace: match + '-once' }; + }); + await ui.executeJavaScript(`window.api.rules.save(${JSON.stringify(manualRules)})`); + await ui.executeJavaScript('window.api.intercept.filter("/manual-rule")'); + await ui.executeJavaScript('window.api.intercept.set(true)'); + await wc.executeJavaScript(`window.__manualRule = fetch('/manual-rule', { method: 'POST', headers: { 'X-Rule-Probe': 'request-token' }, body: 'request-body' }).then(async r => ({ header: r.headers.get('x-response-probe'), data: await r.json() })); true`); + for (let i = 0; i < 80; i++) { if (await ui.executeJavaScript(`ix.items.some(r => r.wcId === ${wc.id})`)) break; await delay(100); } + const editorRewritten = await ui.executeJavaScript(`(async () => { const row = ix.items.find(r => r.wcId === ${wc.id}); await ixOpenItem(row.id); const rewritten = document.getElementById('ix-body-text').value === 'request-body-once'; await ixResolve('continue'); return rewritten; })()`); + const manual = await wc.executeJavaScript('window.__manualRule'); + add('live rules: edited interception forwards all four targets exactly once', editorRewritten && manual.data.body === 'request-body-once' && manual.data.header === 'request-token-once' && manual.header === 'response-token-once' && manual.data.marker === 'response-body-once', manual); + await ui.executeJavaScript('window.api.intercept.set(false)'); + await ui.executeJavaScript('window.api.rules.save([])'); + const replay = await ui.executeJavaScript(`window.api.intercept.repeat({ wcId: ${wc.id}, url: ${JSON.stringify(url + 'echo')}, method: 'POST', postData: 'manual-repeat' })`); + add('Repeat uses the source tab session and cookies', replay.ok && received.some((record) => record.body === 'manual-repeat' && record.cookie.includes('first=one') && record.cookie.includes('second=two'))); + const redirect = await ui.executeJavaScript(`window.api.intercept.repeat({ wcId: ${wc.id}, url: ${JSON.stringify(url + 'redirect')}, method: 'GET' })`); + add('Repeat reports redirects without following a new destination', redirect.ok && redirect.response.status === 302 && !received.some((record) => record.url === '/off-target'), redirect); + await ui.executeJavaScript('window.api.intercept.filter("/queue")'); + await ui.executeJavaScript('window.api.intercept.set(true)'); + await wc.executeJavaScript(`window.__queuedRequests = Promise.all([1,2,3].map(i => fetch('/queue?i=' + i, { method: 'POST', body: 'original-' + i }).then(r => r.json()).catch(() => ({ dropped: true })))); true`); + let queued; + for (let i = 0; i < 80; i++) { + queued = await ui.executeJavaScript(`ix.items.filter(r => r.wcId === ${wc.id}).length`); + if (queued >= 3) break; await delay(100); + } + const queue = await ui.executeJavaScript(`(async () => { + devOpen('intercept'); const rows = ix.items.filter(r => r.wcId === ${wc.id}); + const automatic = !!ix.current && !document.getElementById('ix-detail').classList.contains('hidden'); + const visible = !document.getElementById('ix-list').classList.contains('hidden') && document.querySelectorAll('#ix-list .ix-item').length >= 3; + await ixOpenItem(rows[0].id); document.getElementById('ix-body-text').value = 'edited-first'; + await ixOpenItem(rows[2].id); await ixOpenItem(rows[0].id); + const preserved = document.getElementById('ix-body-text').value === 'edited-first'; + await ixOpenItem(rows[2].id); await ixResolve('drop'); + await ixOpenItem(rows[0].id); await ixResolve('continue'); + const advanced = ix.current === rows[1].id; + await ixResolve('drop'); + return { automatic, visible, preserved, advanced }; + })()`); + const results = await wc.executeJavaScript('window.__queuedRequests'); + add('interception queue remains visible and selects the first request automatically', queued >= 3 && queue.automatic && queue.visible, queue); + add('interception queue preserves drafts while switching and advances after forwarding', queue.preserved && queue.advanced, queue); + add('Forward sends edited data and Drop never reaches the target', results.filter((r) => r.dropped).length === 2 && received.filter((r) => r.url.startsWith('/queue')).length === 1 && received.some((r) => r.url.startsWith('/queue') && r.body === 'edited-first'), results); + } finally { + await ui.executeJavaScript('window.api.intercept.set(false)').catch(() => {}); + await ui.executeJavaScript('window.api.intercept.filter("")').catch(() => {}); + await ui.executeJavaScript(`window.api.rules.save(${JSON.stringify(old || [])})`).catch(() => {}); + if (tab) await ui.executeJavaScript(`closeTab(${JSON.stringify(tab.id)}, { silent: true })`).catch(() => {}); + server.closeAllConnections(); await new Promise((resolve) => server.close(resolve)); + } + return checks; +} +module.exports = { run }; diff --git a/src/main/intercept.js b/src/main/intercept.js index 89c6551..ccd6b64 100644 --- a/src/main/intercept.js +++ b/src/main/intercept.js @@ -1,371 +1,177 @@ 'use strict'; -/** - * Fathi interceptor. Pause web requests and let the UI edit, forward, drop or - * repeat them before they leave the tab. - * - * Implemented with the Chrome DevTools Protocol "Fetch" domain on each tab's - * guest WebContents, so it works together with the Burp proxy: Fathi pauses - * first, then the request goes on to Burp exactly as edited. - * - * Rules: - * - Nothing may stay paused forever. A stuck pause freezes the whole tab, so - * every paused request carries a deadline and is auto-forwarded. - * - Response inspection reuses the flow recorder (network.js) instead of a - * second debugger client, which would fight with DevTools. - */ +/** Shared Fetch client for explicit interception and bounded body rules. + * Header rules belong to session.webRequest and must not be applied twice. */ const settings = require('./settings'); -const rewrite = require('./rewrite'); -const researchScope = require('./research-scope'); - -const AUTO_FORWARD_MS = 120000; // paused request lifetime -const MAX_PAUSED = 80; // hard stop on unbounded pause growth - +const scope = require('./research-scope'); +const executor = require('./rule-executor'); +const MAX_BODY = 65536; +const AUTO_FORWARD_MS = 120000; +const MAX_PAUSED = 80; let win = null; let enabled = false; - -const guests = new Map(); // wcId -> webContents -const paused = new Map(); // requestId -> record -const wired = new WeakSet(); // debugger objects with listeners -const enabling = new Set(); // wcIds with an enable in flight - -/* ---------------------------------------------------------------- helpers */ - -function init(mainWindow) { - win = mainWindow; - enabled = !!(settings.get().intercept || {}).enabled; -} +const guests = new Map(); +const paused = new Map(); +const configuring = new Map(); function send(channel, payload) { - try { - if (win && !win.isDestroyed()) win.webContents.send(channel, payload); - } catch {} -} - -function state() { - return { - enabled, - paused: paused.size, - attached: guests.size, - filter: (settings.get().intercept || {}).filter || '' - }; -} - -function isWebUrl(url) { - return !/^(fathi|chrome-extension|devtools|data|blob|about|chrome|javascript):/i.test(String(url || '')); -} - -function matchesFilter(url) { - const filter = String((settings.get().intercept || {}).filter || '').trim().toLowerCase(); - if (!filter) return true; - const u = String(url || '').toLowerCase(); - return filter.split(/\s+/).some((part) => part && u.includes(part)); + if (win && !win.isDestroyed()) { try { win.webContents.send(channel, payload); } catch {} } +} +function state() { return { enabled, paused: paused.size, ids: [...paused.keys()], attached: guests.size, filter: settings.get().intercept?.filter || '' }; } +function init(window) { win = window; enabled = !!settings.get().intercept?.enabled; } +executor.events.on('failure', error); +function rules(target) { return (settings.get().matchReplace || []).filter((rule) => rule.enabled !== false && rule.match && rule.target === target); } +function isWeb(url) { return /^https?:\/\//i.test(String(url)); } +function matches(url) { + const filter = String(settings.get().intercept?.filter || '').trim().toLowerCase(); + return (!filter || filter.split(/\s+/).some((part) => url.toLowerCase().includes(part))) && scope.allows(url); +} +function error(error) { send('fathi:rules:error', { message: String(error.message || error) }); } +async function rewriteBody(payload, target) { + const list = rules(target); + if (!list.length) return { output: payload, changed: false }; + if (Buffer.byteLength(payload) > MAX_BODY) { error(new Error('Body exceeds 64 KiB; rules skipped')); return { output: payload, changed: false }; } + try { return await executor.apply({ payload, rules: list, target }); } + catch (reason) { error(reason); return { output: payload, changed: false }; } } - -/** Match and Replace on the request headers and body of a paused request. */ -function applyRules(rec) { - const rules = settings.get().matchReplace || []; - if (!rules.length) return { headers: rec.headers, postData: rec.postData }; - const hdr = rewrite.applyHeaders(rec.headers || {}, rules, 'requestHeader'); - const body = rewrite.applyBody(rec.postData || '', rules, 'requestBody'); - return { - headers: hdr.headers, - postData: body.changed ? body.body : rec.postData - }; -} - -/* ------------------------------------------------------------ debugger ops */ - -async function continueRaw(rec) { - try { await rec.wc.debugger.sendCommand('Fetch.continueRequest', { requestId: rec.id }); } catch {} -} - -/* --------------------------------------------------------------- enable */ - -async function enableOn(wc) { - if (!wc || wc.isDestroyed() || enabling.has(wc.id)) return; - enabling.add(wc.id); +function publicRecord(rec) { + return { id: rec.id, wcId: rec.wcId, method: rec.method, url: rec.url, resourceType: rec.resourceType, headers: rec.headers, postData: rec.postData, at: rec.at, stage: 'request', hasResponse: false }; +} +function resolved(id) { paused.delete(id); send('fathi:intercept:resolved', { id }); send('fathi:intercept:state', state()); } +function continuation(rec, edits = {}) { + const params = { requestId: rec.rawId }; + if (edits.url && edits.url !== rec.url) params.url = String(edits.url); + if (edits.method) params.method = String(edits.method).toUpperCase(); + const method = params.method || rec.method; + const body = typeof edits.postData === 'string' ? edits.postData : rec.postData; + const bodyChanged = body !== rec.originalPostData && !/^(GET|HEAD)$/i.test(method); + if (bodyChanged) params.postData = Buffer.from(body, 'utf8').toString('base64'); + if (Array.isArray(edits.headers)) params.headers = edits.headers; + else if (bodyChanged) params.headers = Object.entries(rec.headers).map(([name, value]) => ({ name, value: String(value) })); + if (bodyChanged && params.headers) params.headers = params.headers.filter((header) => !/^(content-length|transfer-encoding)$/i.test(header.name)); + return params; +} +async function resolve({ id, action = 'continue', ...edits } = {}) { + const rec = paused.get(id); + if (!rec) return { ok: false, error: 'Request is no longer paused' }; try { - const dbg = wc.debugger; - if (!dbg.isAttached()) dbg.attach('1.3'); - const patterns = [{ urlPattern: '*', requestStage: 'Request' }]; - // Response bodies are only worth the round trip while the UI can show them. - patterns.push({ urlPattern: '*', requestStage: 'Response' }); - await dbg.sendCommand('Fetch.enable', { patterns }); - } catch (e) { - // Another debugger (DevTools) may be attached; retry on the next load. - } finally { - enabling.delete(wc.id); - } + if (action === 'drop') await rec.wc.debugger.sendCommand('Fetch.failRequest', { requestId: rec.rawId, errorReason: 'Aborted' }); + else await rec.wc.debugger.sendCommand('Fetch.continueRequest', continuation(rec, edits)); + resolved(id); return { ok: true }; + } catch (reason) { return { ok: false, error: String(reason.message || reason) }; } } - -async function disableOn(wc) { +async function drain() { + const ids = [...paused.keys()]; let forwarded = 0; + for (const id of ids) if ((await resolve({ id })).ok) forwarded++; + return { ok: true, forwarded }; +} +async function configure(wc) { if (!wc || wc.isDestroyed()) return; - for (const rec of Array.from(paused.values())) { - if (rec.wcId === wc.id) { - paused.delete(rec.id); - await continueRaw(rec); + if (configuring.has(wc.id)) await configuring.get(wc.id).catch(() => {}); + const job = (async () => { + const patterns = []; + if (enabled || rules('requestBody').length) patterns.push({ urlPattern: '*', requestStage: 'Request' }); + if (rules('responseBody').length) patterns.push({ urlPattern: '*', requestStage: 'Response' }); + if (!patterns.length) { + for (const rec of [...paused.values()]) if (rec.wcId === wc.id) await resolve({ id: rec.id }); + if (wc.debugger.isAttached()) await wc.debugger.sendCommand('Fetch.disable'); + return; } - } + if (!wc.debugger.isAttached()) wc.debugger.attach('1.3'); + await wc.debugger.sendCommand('Fetch.enable', { patterns }); + })(); + configuring.set(wc.id, job); + try { await job; } finally { if (configuring.get(wc.id) === job) configuring.delete(wc.id); } +} +async function refresh() { + await Promise.all([...guests.values()].map((wc) => configure(wc))); +} +async function response(wc, params) { + const requestId = params.requestId; + const headers = params.responseHeaders || []; + const type = headers.find((header) => header.name.toLowerCase() === 'content-type')?.value || ''; + const length = Number(headers.find((header) => header.name.toLowerCase() === 'content-length')?.value || 0); + const status = params.responseStatusCode; + const text = /^(text\/|application\/(?:json|javascript|xml|x-www-form-urlencoded))|\+(?:json|xml)(?:;|$)/i.test(type); try { - if (wc.debugger.isAttached()) await wc.debugger.sendCommand('Fetch.disable'); - } catch {} + if (rules('responseBody').length && isWeb(params.request?.url) && text && status >= 200 && status < 300 && status !== 204 && status !== 206 && params.request?.method !== 'HEAD' && length <= MAX_BODY) { + const body = await wc.debugger.sendCommand('Fetch.getResponseBody', { requestId }); + const payload = body.base64Encoded ? new TextDecoder('utf-8', { fatal: true }).decode(Buffer.from(body.body, 'base64')) : String(body.body || ''); + const result = await rewriteBody(payload, 'responseBody'); + if (result.changed) { + const responseHeaders = headers.filter((header) => !/^(content-length|content-encoding|transfer-encoding|etag|content-md5|digest)$/i.test(header.name)).map((header) => header.name.toLowerCase() === 'content-type' ? { ...header, value: header.value.replace(/;\s*charset\s*=\s*["']?[^;"'\s]+["']?/i, '') + '; charset=utf-8' } : header); + responseHeaders.push({ name: 'Content-Length', value: String(Buffer.byteLength(result.output)) }); + await wc.debugger.sendCommand('Fetch.fulfillRequest', { requestId, responseCode: status, responseHeaders, body: Buffer.from(result.output).toString('base64') }); + return; + } + } else if (rules('responseBody').length && length > MAX_BODY) error(new Error('Response exceeds 64 KiB; body rules skipped')); + } catch (reason) { error(reason); } + try { await wc.debugger.sendCommand('Fetch.continueResponse', { requestId }); } + catch { await wc.debugger.sendCommand('Fetch.continueRequest', { requestId }).catch(() => {}); } +} +async function request(wc, params) { + if (params.responseStatusCode !== undefined || params.responseErrorReason) return response(wc, params); + const input = params.request; + if (!input || !params.requestId) return; + const rec = { id: `${wc.id}:${params.requestId}`, rawId: params.requestId, wcId: wc.id, wc, url: input.url, method: input.method || 'GET', headers: input.headers || {}, postData: input.postData || '', originalPostData: input.postData || '', resourceType: params.resourceType || 'Other', at: Date.now(), deadline: Date.now() + AUTO_FORWARD_MS }; + if (isWeb(rec.url) && !/^(GET|HEAD)$/i.test(rec.method)) { + if (input.hasPostData && typeof input.postData !== 'string' && rules('requestBody').length) error(new Error('Request body is not available as text; body rules skipped')); + else rec.postData = (await rewriteBody(rec.postData, 'requestBody')).output; + } + if (!enabled || !isWeb(rec.url) || !matches(rec.url) || paused.size >= MAX_PAUSED) { + await wc.debugger.sendCommand('Fetch.continueRequest', continuation(rec)); return; + } + paused.set(rec.id, rec); send('fathi:intercept:paused', publicRecord(rec)); send('fathi:intercept:state', state()); } - -/* ---------------------------------------------------------------- wiring */ - function attach(wc) { if (!wc || guests.has(wc.id)) return; guests.set(wc.id, wc); - - const dbg = wc.debugger; - if (!wired.has(dbg)) { - wired.add(dbg); - dbg.on('message', (_e, method, params) => onMessage(wc, method, params)); - dbg.on('detach', () => { - // DevTools took the debugger; every pause it owned is gone with it. - for (const rec of Array.from(paused.values())) { - if (rec.wcId === wc.id) paused.delete(rec.id); - } - send('fathi:intercept:state', state()); - }); - } - - const kick = () => { if (enabled) enableOn(wc).catch(() => {}); }; - kick(); - wc.once('dom-ready', kick); - - wc.once('destroyed', () => { - guests.delete(wc.id); - for (const rec of Array.from(paused.values())) { - if (rec.wcId === wc.id) paused.delete(rec.id); - } - send('fathi:intercept:state', state()); - }); + wc.debugger.on('message', (_event, method, params) => { if (method === 'Fetch.requestPaused') request(wc, params).catch(error); }); + const forget = () => { for (const rec of [...paused.values()]) if (rec.wcId === wc.id) resolved(rec.id); }; + wc.debugger.on('detach', forget); + wc.once('destroyed', () => { forget(); guests.delete(wc.id); }); + const kick = () => configure(wc).catch(error); + kick(); wc.once('dom-ready', kick); wc.on('devtools-closed', kick); } - -/* --------------------------------------------------------------- capture */ - -function emitPaused(rec) { - paused.set(rec.id, { ...rec, wc: rec.wc }); - send('fathi:intercept:paused', publicRecord(rec)); - send('fathi:intercept:state', state()); -} - -function publicRecord(rec) { - return { - id: rec.id, - wcId: rec.wcId, - method: rec.method, - url: rec.url, - resourceType: rec.resourceType, - headers: rec.headers || {}, - postData: rec.postData || '', - at: rec.at, - stage: rec.stage || 'request', - hasResponse: !!rec.hasResponse - }; -} - -async function onMessage(wc, method, params) { - if (method === 'Fetch.requestPaused') return onRequestPaused(wc, params); - if (method === 'Fetch.responsePaused') return onResponsePaused(wc, params); -} - -async function onRequestPaused(wc, params) { - const { requestId, request, resourceType } = params || {}; - if (!requestId || !request) return; - - const rec = { - id: requestId, - wcId: wc.id, - method: request.method || 'GET', - url: request.url || '', - resourceType: resourceType || 'Other', - headers: request.headers || {}, - postData: request.postData || '', - at: Date.now(), - stage: 'request', - wc - }; - - if (!enabled || !isWebUrl(rec.url) || !matchesFilter(rec.url) || !researchScope.allows(rec.url)) { - try { await wc.debugger.sendCommand('Fetch.continueRequest', { requestId }); } catch {} - return; - } - - if (paused.size >= MAX_PAUSED) { - // Refuse to pile up. Reading the list is still possible while paused. - try { await wc.debugger.sendCommand('Fetch.continueRequest', { requestId }); } catch {} - return; - } - - const rewritten = applyRules(rec); - rec.headers = rewritten.headers; - rec.postData = rewritten.postData; - rec.deadline = Date.now() + AUTO_FORWARD_MS; - emitPaused(rec); -} - -async function onResponsePaused(wc, params) { - const { requestId } = params || {}; - const rec = requestId ? paused.get(requestId) : null; - // Only keep a response pause alive when the UI is actually inspecting it. - if (!rec || !rec.watchResponse) { - try { await wc.debugger.sendCommand('Fetch.continueResponse', { requestId }); } catch {} - return; - } - rec.hasResponse = true; - rec.responseHeaders = params.responseHeaders || {}; - rec.responseStatusCode = params.responseStatusCode || 0; - send('fathi:intercept:paused', publicRecord(rec)); +async function setEnabled(on) { + enabled = !!on; settings.save({ intercept: { enabled } }); + if (!enabled) await drain(); + await refresh(); send('fathi:intercept:state', state()); + return state(); } +function setFilter(filter) { settings.save({ intercept: { filter: String(filter || '') } }); send('fathi:intercept:state', state()); return state(); } +setInterval(() => { for (const rec of paused.values()) if (Date.now() > rec.deadline) resolve({ id: rec.id }).catch(() => {}); }, 5000).unref?.(); -/* ------------------------------------------------------------- operations */ - -/** - * Send one request through a clean tab session and return the response. - * Used by the Repeat action: same URL, method and headers, body as edited. - * Runs on a throwaway in-memory session so it inherits proxy and cert trust - * without touching the tab that originated the request. - */ -async function sendRequest({ url, method = 'GET', headers = {}, postData = '', partition = '' } = {}) { - if (!url) return { ok: false, error: 'missing url' }; +async function sendRequest({ url, method = 'GET', headers = {}, postData = '', partition } = {}) { + if (!isWeb(url) || !partition) return { ok: false, error: 'Repeat requires a known tab and an HTTP(S) URL' }; const { net, session } = require('electron'); const started = Date.now(); - - let ses = null; + const verb = String(method).toUpperCase(); + // The editor already contains request-body rule output. Repeat sends those + // explicit edits as-is rather than applying non-idempotent rules twice. + const payload = /^(GET|HEAD)$/.test(verb) ? '' : String(postData); try { - ses = partition ? session.fromPartition(partition) : session.fromPartition('fathi-repeat-' + Date.now().toString(36)); - } catch {} - - try { - const res = await new Promise((resolvePromise, rejectPromise) => { - const req = ses - ? net.request({ session: ses, method: String(method || 'GET').toUpperCase(), url, redirect: 'follow' }) - : net.request({ method: String(method || 'GET').toUpperCase(), url, redirect: 'follow' }); - - for (const [name, value] of Object.entries(headers || {})) { - try { req.setHeader(String(name), String(value)); } catch {} - } - - const done = (payload) => resolvePromise(payload); - req.on('response', (response) => { - const chunks = []; - let bytes = 0; - const mime = String(response.headers['content-type'] || ''); - response.on('data', (chunk) => { - bytes += chunk.length; - if (bytes <= 512 * 1024) chunks.push(chunk); - }); - response.on('end', () => { - const body = Buffer.concat(chunks).toString('utf8'); - done({ - status: response.statusCode, - statusText: response.statusMessage || '', - headers: response.headers || {}, - mimeType: mime, - body, - truncated: bytes > 512 * 1024, - size: bytes, - time: Date.now() - started - }); - }); - response.on('error', (e) => rejectPromise(e)); + const result = await new Promise((accept, reject) => { + const req = net.request({ session: session.fromPartition(partition), useSessionCookies: true, method: verb, url, redirect: 'manual' }); + const timer = setTimeout(() => { req.abort(); reject(new Error('Repeat timed out after 15 seconds')); }, 15000); + const done = (value) => { clearTimeout(timer); accept(value); }; + for (const [name, value] of Object.entries(headers)) if (!/^(content-length|transfer-encoding)$/i.test(name)) { try { req.setHeader(name, String(value)); } catch {} } + req.on('redirect', (status, _method, target, responseHeaders) => { done({ status, statusText: 'Redirect not followed', headers: responseHeaders, redirectURL: target, body: '', time: Date.now() - started }); req.abort(); }); + req.on('error', (reason) => { clearTimeout(timer); reject(reason); }); + req.on('login', (auth, callback) => { + if (!auth.isProxy) { callback(); return; } + const entry = require('./proxy').entryFor(partition); + callback(entry?.username || '', entry?.password || ''); }); - req.on('error', (e) => rejectPromise(e)); - - if (postData && !/^(GET|HEAD)$/i.test(method)) req.write(String(postData)); - req.end(); + req.on('response', (res) => { + const chunks = []; let bytes = 0; + const finish = () => done({ status: res.statusCode, statusText: res.statusMessage, headers: res.headers, mimeType: String(res.headers['content-type'] || ''), body: Buffer.concat(chunks).toString('utf8'), size: bytes, truncated: bytes > 512 * 1024, time: Date.now() - started }); + res.on('data', (chunk) => { bytes += chunk.length; if (bytes <= 512 * 1024) chunks.push(chunk); else { finish(); req.abort(); } }); + res.on('end', finish); res.on('error', (reason) => { clearTimeout(timer); reject(reason); }); + }); + if (payload) req.write(payload); req.end(); }); - - return { ok: true, response: res }; - } catch (e) { - return { ok: false, error: String(e && e.message || e) }; - } -} - -async function resolve({ id, action = 'continue', url, method, headers, postData } = {}) { - const rec = paused.get(id); - if (!rec) return { ok: false, error: 'request is no longer paused' }; - paused.delete(id); - - try { - if (action === 'drop') { - await rec.wc.debugger.sendCommand('Fetch.failRequest', { requestId: id, errorReason: 'Aborted' }); - } else { - const params = { requestId: id }; - if (url && url !== rec.url) params.url = String(url); - if (method && method !== rec.method) params.method = String(method).toUpperCase(); - if (Array.isArray(headers) && headers.length) params.headers = headers; - const useMethod = params.method || rec.method; - if (typeof postData === 'string' && postData !== rec.postData && !/^(GET|HEAD)$/i.test(useMethod)) { - params.postData = Buffer.from(postData, 'utf8').toString('base64'); - } - if (rec.stage === 'response') { - await rec.wc.debugger.sendCommand('Fetch.continueResponse', { requestId: id }); - } else { - await rec.wc.debugger.sendCommand('Fetch.continueRequest', params); - } - } - } catch (e) { - send('fathi:intercept:state', state()); - return { ok: false, error: String(e && e.message || e) }; - } - - send('fathi:intercept:resolved', { id }); - send('fathi:intercept:state', state()); - return { ok: true }; + if (rules('responseBody').length && result.body) result.body = (await rewriteBody(result.body, 'responseBody')).output; + return { ok: true, response: result }; + } catch (reason) { return { ok: false, error: String(reason.message || reason) }; } } - -async function drain() { - const all = Array.from(paused.values()); - paused.clear(); - for (const rec of all) { - if (rec.stage === 'response') { - try { await rec.wc.debugger.sendCommand('Fetch.continueResponse', { requestId: rec.id }); } catch {} - } else { - await continueRaw(rec); - } - } - send('fathi:intercept:state', state()); - return { ok: true, forwarded: all.length }; -} - -/* -------------------------------------------------------------- lifecycle */ - -/** Auto-forward anything the user left sitting for too long. */ -setInterval(() => { - const now = Date.now(); - for (const rec of Array.from(paused.values())) { - if (rec.deadline && now > rec.deadline) { - paused.delete(rec.id); - if (rec.stage === 'response') { - try { rec.wc.debugger.sendCommand('Fetch.continueResponse', { requestId: rec.id }); } catch {} - } else { - continueRaw(rec); - } - } - } -}, 5000).unref?.(); - -async function setEnabled(on) { - enabled = !!on; - settings.save({ intercept: { enabled } }); - - for (const wc of guests.values()) { - if (enabled) await enableOn(wc); - else await disableOn(wc); - } - - send('fathi:intercept:state', state()); - if (win && !win.isDestroyed()) win.webContents.send('fathi:settings:changed', settings.get()); - return state(); -} - -function setFilter(filter) { - settings.save({ intercept: { filter: String(filter || '') } }); - send('fathi:intercept:state', state()); - return state(); -} - -module.exports = { init, attach, resolve, drain, setEnabled, setFilter, state, sendRequest }; +module.exports = { init, attach, resolve, drain, setEnabled, setFilter, state, sendRequest, refresh, ready: configure }; diff --git a/src/main/main.js b/src/main/main.js index 5487246..2cb89f1 100644 --- a/src/main/main.js +++ b/src/main/main.js @@ -409,6 +409,7 @@ ipcMain.handle('fathi:tab:ready', async (event, wcId) => { const rec = wc && recordForWebContents(wc); if (!rec) return fail('Unknown tab session'); await identityRuntime.ready(wc, rec.fp); + await intercept.ready(wc); return ok({}); } catch (error) { return fail(error); } }); @@ -576,7 +577,11 @@ ipcMain.handle('fathi:intercept:filter', (event, { filter } = {}) => { /* --- repeat: resend an edited request and return its response */ ipcMain.handle('fathi:intercept:repeat', async (event, payload = {}) => { try { - const res = await intercept.sendRequest(payload); + if (event.sender !== mainWindow?.webContents) return fail('Only browser chrome may repeat requests'); + const wc = webContents.fromId(Number(payload.wcId)); + const rec = wc && recordForWebContents(wc); + if (!rec) return fail('The source tab has closed'); + const res = await intercept.sendRequest({ ...payload, partition: rec.partition }); return res.ok ? ok({ response: res.response }) : fail(res.error); } catch (e) { return fail(e); } }); @@ -615,7 +620,8 @@ ipcMain.handle('fathi:rules:test', async (_event, input) => { }); }); -ipcMain.handle('fathi:rules:save', (event, { rules } = {}) => { +ipcMain.handle('fathi:rules:save', async (event, { rules } = {}) => { + if (event.sender !== mainWindow?.webContents) return fail('Only browser chrome may change rules'); try { const clean = (Array.isArray(rules) ? rules : []).map((r) => ({ id: String(r && r.id || rewrite.newId()), @@ -626,7 +632,10 @@ ipcMain.handle('fathi:rules:save', (event, { rules } = {}) => { regex: !!(r && r.regex), caseSensitive: !!(r && r.caseSensitive) })).filter((r) => r.match); + if (clean.length > 100 || clean.some((rule) => rule.match.length > 4096 || rule.replace.length > 65536)) return fail('Rules exceed supported limits'); + for (const rule of clean) if (rule.regex) { try { new RegExp(rule.match); } catch { return fail('Invalid regular expression'); } } const cfg = settings.save({ matchReplace: clean }); + await intercept.refresh(); if (mainWindow) mainWindow.webContents.send('fathi:settings:changed', cfg); return ok({ rules: cfg.matchReplace }); } catch (e) { return fail(e); } diff --git a/src/main/rewrite.js b/src/main/rewrite.js index 3ab2d67..3d38483 100644 --- a/src/main/rewrite.js +++ b/src/main/rewrite.js @@ -51,10 +51,10 @@ function forTarget(rules, target) { function applyString(value, compiled) { let text = String(value == null ? '' : value); let changed = false; - for (const { re, replace } of compiled) { + for (const { re, replace, rule } of compiled) { // A fresh lastIndex per call keeps global regexes deterministic. re.lastIndex = 0; - const next = text.replace(re, replace); + const next = rule.regex ? text.replace(re, replace) : text.replace(re, () => replace); if (next !== text) { text = next; changed = true; @@ -70,9 +70,13 @@ function applyHeaders(headers, rules, target) { const out = {}; let changed = false; for (const [name, value] of Object.entries(headers)) { - const res = applyString(String(value), compiled); - if (res.changed) changed = true; - out[name] = res.text; + const values = Array.isArray(value) ? value : [value]; + const replaced = values.map((item) => { + const result = applyString(String(item), compiled); + if (result.changed) changed = true; + return result.text; + }); + out[name] = Array.isArray(value) ? replaced : replaced[0]; } return { headers: changed ? out : headers, changed }; } diff --git a/src/main/rule-executor.js b/src/main/rule-executor.js new file mode 100644 index 0000000..a3112a7 --- /dev/null +++ b/src/main/rule-executor.js @@ -0,0 +1,29 @@ +'use strict'; +const { Worker } = require('node:worker_threads'); +const events = new (require('node:events').EventEmitter)(); +const queue = []; +let active = 0; +function pump() { + while (active < 2 && queue.length) { + const job = queue.shift(); active++; + let worker; + try { worker = new Worker(require.resolve('./rule-test-worker'), { workerData: job.input }); } + catch (error) { active--; job.reject(error); continue; } + let finished = false; + const finish = (error, result) => { + if (finished) return; + finished = true; clearTimeout(timer); worker.terminate(); active--; + if (error) job.reject(error); else job.resolve(result); + pump(); + }; + const timer = setTimeout(() => finish(new Error('Rule execution timed out')), 1500); + worker.once('message', (result) => finish(result.error ? new Error(result.error) : null, result)); + worker.once('error', (error) => finish(error)); + worker.once('exit', (code) => { if (!finished) finish(new Error(`Rule worker exited (${code})`)); }); + } +} +function apply(input) { + const result = queue.length >= 32 ? Promise.reject(new Error('Rule queue is full; request continued unchanged')) : new Promise((resolve, reject) => { queue.push({ input, resolve, reject }); pump(); }); + return result.catch((error) => { events.emit('failure', error); throw error; }); +} +module.exports = { apply, events }; diff --git a/src/main/rule-test-worker.js b/src/main/rule-test-worker.js index 322254c..f047ba1 100644 --- a/src/main/rule-test-worker.js +++ b/src/main/rule-test-worker.js @@ -1,7 +1,12 @@ 'use strict'; const { parentPort, workerData } = require('node:worker_threads'); try { - parentPort.postMessage(require('./rewrite').test(workerData)); + const rewrite = require('./rewrite'); + if (workerData.kind === 'headers') { + if (!rewrite.HEADER_TARGETS.has(workerData.target) || JSON.stringify(workerData.headers).length > 65536) throw new Error('Headers exceed the supported 64 Ki character limit'); + rewrite.test({ rules: workerData.rules, target: workerData.target, payload: '' }); + parentPort.postMessage(rewrite.applyHeaders(workerData.headers, workerData.rules, workerData.target)); + } else parentPort.postMessage(rewrite.test(workerData)); } catch (error) { parentPort.postMessage({ error: error.message }); } diff --git a/src/main/session.js b/src/main/session.js index 271183b..a5470e2 100644 --- a/src/main/session.js +++ b/src/main/session.js @@ -89,9 +89,11 @@ function configureSession(ses, fp, partition, opts = {}) { // Match and Replace on request headers, before anything leaves the tab. const rules = (settings.get().matchReplace || []); - const hdr = rewrite.applyHeaders(h, rules, 'requestHeader'); - - callback({ requestHeaders: hdr.headers }); + if (!rules.some((rule) => rule.enabled !== false && rule.target === 'requestHeader' && rule.match)) return callback({ requestHeaders: h }); + require('./rule-executor').apply({ kind: 'headers', rules, target: 'requestHeader', headers: h }).then( + (result) => callback({ requestHeaders: result.headers }), + () => callback({ requestHeaders: h }) + ); }); } catch (e) { console.error('[session] header hook', e); } @@ -99,16 +101,11 @@ function configureSession(ses, fp, partition, opts = {}) { try { ses.webRequest.onHeadersReceived({ urls: ['*://*/*'] }, (details, callback) => { const rules = settings.get().matchReplace || []; - if (!rules.length) return callback({}); - const h = {}; - for (const [name, value] of Object.entries(details.responseHeaders || {})) { - h[name] = Array.isArray(value) ? value.join(', ') : String(value); - } - const res = rewrite.applyHeaders(h, rules, 'responseHeader'); - if (!res.changed) return callback({}); - const out = {}; - for (const [name, value] of Object.entries(res.headers)) out[name] = [String(value)]; - callback({ responseHeaders: out }); + if (!rules.some((rule) => rule.enabled !== false && rule.target === 'responseHeader' && rule.match)) return callback({}); + require('./rule-executor').apply({ kind: 'headers', rules, target: 'responseHeader', headers: details.responseHeaders || {} }).then( + (result) => callback(result.changed ? { responseHeaders: result.headers } : {}), + () => callback({}) + ); }); } catch {} diff --git a/src/preload/ui.js b/src/preload/ui.js index 9d3f8e9..1f9aee1 100644 --- a/src/preload/ui.js +++ b/src/preload/ui.js @@ -13,6 +13,7 @@ const EVENTS = new Set([ 'fathi:proxy:changed', 'fathi:tor:changed', 'fathi:update:state', + 'fathi:rules:error', 'fathi:settings:changed', 'fathi:intercept:paused', 'fathi:intercept:resolved', diff --git a/src/renderer/app.js b/src/renderer/app.js index 4971274..b5fd39b 100644 --- a/src/renderer/app.js +++ b/src/renderer/app.js @@ -791,7 +791,7 @@ document.addEventListener('mousedown', (e) => { /* -------------------------------------------------- flow + dev drawer */ -const ix = { enabled: false, items: [], current: null, filter: '', view: 'request' }; +const ix = { enabled: false, items: [], current: null, filter: '', view: 'request', drafts: new Map() }; const flow = { wcId: null, @@ -1079,19 +1079,13 @@ function ixUpdateChrome() { const count = ix.items.length; function ixRenderList() { const box = $('#ix-list'); if (!box) return; - const needle = String(ix.filter || '').trim().toLowerCase(); - const list = needle - ? ix.items.filter((r) => { - const hay = `${r.method} ${r.url} ${r.resourceType} ${r.postData || ''} ${JSON.stringify(r.headers || {})}`.toLowerCase(); - return needle.split(/\s+/).filter(Boolean).every((part) => hay.includes(part)); - }) - : ix.items; + const list = ix.items; if (!list.length) { box.innerHTML = `
${esc(t('intercept.empty'))}
`; return; } box.innerHTML = list.map((r) => ` -