/* eslint-disable */
/**
* Network Capture Helper
*
* This script helps replay network requests with the original cookies and headers.
*/
// Prevent duplicate initialization
if (window.__NETWORK_CAPTURE_HELPER_INITIALIZED__) {
// Already initialized, skip
} else {
window.__NETWORK_CAPTURE_HELPER_INITIALIZED__ = true;
/**
* Replay a network request
* @param {string} url - The URL to send the request to
* @param {string} method - The HTTP method to use
* @param {Object} headers - The headers to include in the request
* @param {any} body - The body of the request
* @param {number} timeout - Timeout in milliseconds (default: 30000)
* @returns {Promise<Object>} - The response data
*/
async function replayNetworkRequest(
url,
method,
headers,
body,
timeout = 30000,
formDataDescriptor = null,
) {
try {
// Create fetch options
const options = {
method: method,
headers: headers || {},
credentials: 'include', // Include cookies
mode: 'cors',
cache: 'no-cache',
};
// Helper: convert base64 to Blob
const base64ToBlob = (base64, contentType = 'application/octet-stream') => {
try {
const decodedString = atob(base64);
const len = decodedString.length;
const bytes = new Uint8Array(len);
for (let i = 0; i < len; i++) bytes[i] = decodedString.charCodeAt(i);
return new Blob([bytes], { type: contentType });
} catch (e) {
return new Blob([]);
}
};
// Helper: request native to read filePath into base64
const readFileBase64 = (path) =>
new Promise((resolve) => {
const requestId = `net-helper-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
const timeoutId = setTimeout(() => {
cleanup();
resolve(null);
}, 30000);
function onMessage(msg) {
if (
msg &&
msg.type === 'file_operation_response' &&
msg.responseToRequestId === requestId
) {
cleanup();
const p = msg.payload || {};
if (p.success && p.base64Data)
resolve({ base64: p.base64Data, fileName: p.fileName });
else resolve(null);
}
}
function cleanup() {
clearTimeout(timeoutId);
chrome.runtime.onMessage.removeListener(onMessage);
}
chrome.runtime.onMessage.addListener(onMessage);
chrome.runtime
.sendMessage({
type: 'forward_to_native',
message: {
type: 'file_operation',
requestId,
payload: { action: 'readBase64File', filePath: path },
},
})
.catch(() => {
cleanup();
resolve(null);
});
});
// Build multipart/form-data if descriptor is provided
if (method !== 'GET' && method !== 'HEAD' && formDataDescriptor) {
const fd = new FormData();
try {
if (Array.isArray(formDataDescriptor)) {
for (const item of formDataDescriptor) {
if (!Array.isArray(item) || item.length < 2) continue;
const name = String(item[0] || 'file');
const spec = String(item[1] || '');
const filenameHint = item[2] ? String(item[2]) : undefined;
if (/^(https?:\/\/|url:)/i.test(spec)) {
const url = spec.replace(/^url:/i, '');
const resp = await fetch(url);
const blob = await resp.blob();
const fn =
filenameHint || url.split('?')[0].split('#')[0].split('/').pop() || 'file';
fd.append(name, blob, fn);
} else if (/^base64:/i.test(spec)) {
const b64 = spec.replace(/^base64:/i, '');
const blob = base64ToBlob(b64);
fd.append(name, blob, filenameHint || 'file');
} else if (/^file:/i.test(spec)) {
const p = spec.replace(/^file:/i, '');
const res = await readFileBase64(p);
if (res && res.base64) {
const blob = base64ToBlob(res.base64);
fd.append(name, blob, filenameHint || res.fileName || 'file');
}
} else {
// treat as string field
fd.append(name, spec);
}
}
} else if (typeof formDataDescriptor === 'object') {
const fds = formDataDescriptor;
const fields = fds.fields || {};
const files = Array.isArray(fds.files) ? fds.files : [];
for (const [k, v] of Object.entries(fields)) fd.append(String(k), String(v));
for (const file of files) {
const name = String(file.name || 'file');
if (file.fileUrl) {
const resp = await fetch(String(file.fileUrl));
const blob = await resp.blob();
const fn =
file.filename ||
String(file.fileUrl).split('?')[0].split('#')[0].split('/').pop() ||
'file';
fd.append(name, blob, fn);
} else if (file.base64Data) {
const blob = base64ToBlob(
String(file.base64Data),
String(file.contentType || 'application/octet-stream'),
);
fd.append(name, blob, file.filename || 'file');
} else if (file.filePath) {
const res = await readFileBase64(String(file.filePath));
if (res && res.base64) {
const blob = base64ToBlob(
res.base64,
String(file.contentType || 'application/octet-stream'),
);
fd.append(name, blob, file.filename || res.fileName || 'file');
}
}
}
}
} catch (e) {
console.warn('Failed to construct FormData:', e);
}
// Let browser set the correct multipart boundary
try {
if (options.headers) {
delete options.headers['content-type'];
delete options.headers['Content-Type'];
}
} catch {}
options.body = fd;
} else if (method !== 'GET' && method !== 'HEAD' && body !== undefined) {
// Fallback to raw body
options.body = body;
}
// 创建一个带超时的 fetch
const fetchWithTimeout = async (url, options, timeout) => {
const controller = new AbortController();
const signal = controller.signal;
// 设置超时
const timeoutId = setTimeout(() => controller.abort(), timeout);
try {
const response = await fetch(url, { ...options, signal });
clearTimeout(timeoutId);
return response;
} catch (error) {
clearTimeout(timeoutId);
throw error;
}
};
// 发送带超时的请求
const response = await fetchWithTimeout(url, options, timeout);
// Process response
const responseData = {
status: response.status,
statusText: response.statusText,
headers: {},
};
// Get response headers
response.headers.forEach((value, key) => {
responseData.headers[key] = value;
});
// Try to get response body based on content type
const contentType = response.headers.get('content-type') || '';
try {
if (contentType.includes('application/json')) {
responseData.body = await response.json();
} else if (
contentType.includes('text/') ||
contentType.includes('application/xml') ||
contentType.includes('application/javascript')
) {
responseData.body = await response.text();
} else {
// For binary data, just indicate it was received but not parsed
responseData.body = '[Binary data not displayed]';
}
} catch (error) {
responseData.body = `[Error parsing response body: ${error.message}]`;
}
return {
success: true,
response: responseData,
};
} catch (error) {
console.error('Error replaying request:', error);
return {
success: false,
error: `Error replaying request: ${error.message}`,
};
}
}
// Listen for messages from the extension
chrome.runtime.onMessage.addListener((request, _sender, sendResponse) => {
// Respond to ping message
if (request.action === 'chrome_network_request_ping') {
sendResponse({ status: 'pong' });
return false; // Synchronous response
} else if (request.action === 'sendPureNetworkRequest') {
replayNetworkRequest(
request.url,
request.method,
request.headers,
request.body,
request.timeout,
request.formData,
)
.then(sendResponse)
.catch((error) => {
sendResponse({
success: false,
error: `Unexpected error: ${error.message}`,
});
});
return true; // Indicates async response
}
});
}
