This is page 4 of 8. Use http://codebase.md/hangwin/mcp-chrome?page={x} to view the full context.
# Directory Structure
```
├── .gitattributes
├── .github
│ └── workflows
│ └── build-release.yml
├── .gitignore
├── .husky
│ ├── commit-msg
│ └── pre-commit
├── .prettierignore
├── .prettierrc.json
├── .vscode
│ └── extensions.json
├── app
│ ├── chrome-extension
│ │ ├── _locales
│ │ │ ├── de
│ │ │ │ └── messages.json
│ │ │ ├── en
│ │ │ │ └── messages.json
│ │ │ ├── ja
│ │ │ │ └── messages.json
│ │ │ ├── ko
│ │ │ │ └── messages.json
│ │ │ ├── zh_CN
│ │ │ │ └── messages.json
│ │ │ └── zh_TW
│ │ │ └── messages.json
│ │ ├── .env.example
│ │ ├── assets
│ │ │ └── vue.svg
│ │ ├── common
│ │ │ ├── constants.ts
│ │ │ ├── message-types.ts
│ │ │ └── tool-handler.ts
│ │ ├── entrypoints
│ │ │ ├── background
│ │ │ │ ├── index.ts
│ │ │ │ ├── native-host.ts
│ │ │ │ ├── semantic-similarity.ts
│ │ │ │ ├── storage-manager.ts
│ │ │ │ └── tools
│ │ │ │ ├── base-browser.ts
│ │ │ │ ├── browser
│ │ │ │ │ ├── bookmark.ts
│ │ │ │ │ ├── common.ts
│ │ │ │ │ ├── console.ts
│ │ │ │ │ ├── file-upload.ts
│ │ │ │ │ ├── history.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── inject-script.ts
│ │ │ │ │ ├── interaction.ts
│ │ │ │ │ ├── keyboard.ts
│ │ │ │ │ ├── network-capture-debugger.ts
│ │ │ │ │ ├── network-capture-web-request.ts
│ │ │ │ │ ├── network-request.ts
│ │ │ │ │ ├── screenshot.ts
│ │ │ │ │ ├── vector-search.ts
│ │ │ │ │ ├── web-fetcher.ts
│ │ │ │ │ └── window.ts
│ │ │ │ └── index.ts
│ │ │ ├── content.ts
│ │ │ ├── offscreen
│ │ │ │ ├── index.html
│ │ │ │ └── main.ts
│ │ │ └── popup
│ │ │ ├── App.vue
│ │ │ ├── components
│ │ │ │ ├── ConfirmDialog.vue
│ │ │ │ ├── icons
│ │ │ │ │ ├── BoltIcon.vue
│ │ │ │ │ ├── CheckIcon.vue
│ │ │ │ │ ├── DatabaseIcon.vue
│ │ │ │ │ ├── DocumentIcon.vue
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── TabIcon.vue
│ │ │ │ │ ├── TrashIcon.vue
│ │ │ │ │ └── VectorIcon.vue
│ │ │ │ ├── ModelCacheManagement.vue
│ │ │ │ └── ProgressIndicator.vue
│ │ │ ├── index.html
│ │ │ ├── main.ts
│ │ │ └── style.css
│ │ ├── eslint.config.js
│ │ ├── inject-scripts
│ │ │ ├── click-helper.js
│ │ │ ├── fill-helper.js
│ │ │ ├── inject-bridge.js
│ │ │ ├── interactive-elements-helper.js
│ │ │ ├── keyboard-helper.js
│ │ │ ├── network-helper.js
│ │ │ ├── screenshot-helper.js
│ │ │ └── web-fetcher-helper.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── public
│ │ │ ├── icon
│ │ │ │ ├── 128.png
│ │ │ │ ├── 16.png
│ │ │ │ ├── 32.png
│ │ │ │ ├── 48.png
│ │ │ │ └── 96.png
│ │ │ ├── libs
│ │ │ │ └── ort.min.js
│ │ │ └── wxt.svg
│ │ ├── README.md
│ │ ├── tsconfig.json
│ │ ├── utils
│ │ │ ├── content-indexer.ts
│ │ │ ├── i18n.ts
│ │ │ ├── image-utils.ts
│ │ │ ├── lru-cache.ts
│ │ │ ├── model-cache-manager.ts
│ │ │ ├── offscreen-manager.ts
│ │ │ ├── semantic-similarity-engine.ts
│ │ │ ├── simd-math-engine.ts
│ │ │ ├── text-chunker.ts
│ │ │ └── vector-database.ts
│ │ ├── workers
│ │ │ ├── ort-wasm-simd-threaded.jsep.mjs
│ │ │ ├── ort-wasm-simd-threaded.jsep.wasm
│ │ │ ├── ort-wasm-simd-threaded.mjs
│ │ │ ├── ort-wasm-simd-threaded.wasm
│ │ │ ├── simd_math_bg.wasm
│ │ │ ├── simd_math.js
│ │ │ └── similarity.worker.js
│ │ └── wxt.config.ts
│ └── native-server
│ ├── debug.sh
│ ├── install.md
│ ├── jest.config.js
│ ├── package.json
│ ├── README.md
│ ├── src
│ │ ├── cli.ts
│ │ ├── constant
│ │ │ └── index.ts
│ │ ├── file-handler.ts
│ │ ├── index.ts
│ │ ├── mcp
│ │ │ ├── mcp-server-stdio.ts
│ │ │ ├── mcp-server.ts
│ │ │ ├── register-tools.ts
│ │ │ └── stdio-config.json
│ │ ├── native-messaging-host.ts
│ │ ├── scripts
│ │ │ ├── browser-config.ts
│ │ │ ├── build.ts
│ │ │ ├── constant.ts
│ │ │ ├── postinstall.ts
│ │ │ ├── register-dev.ts
│ │ │ ├── register.ts
│ │ │ ├── run_host.bat
│ │ │ ├── run_host.sh
│ │ │ └── utils.ts
│ │ ├── server
│ │ │ ├── index.ts
│ │ │ └── server.test.ts
│ │ └── util
│ │ └── logger.ts
│ └── tsconfig.json
├── commitlint.config.cjs
├── docs
│ ├── ARCHITECTURE_zh.md
│ ├── ARCHITECTURE.md
│ ├── CHANGELOG.md
│ ├── CONTRIBUTING_zh.md
│ ├── CONTRIBUTING.md
│ ├── TOOLS_zh.md
│ ├── TOOLS.md
│ ├── TROUBLESHOOTING_zh.md
│ ├── TROUBLESHOOTING.md
│ └── WINDOWS_INSTALL_zh.md
├── eslint.config.js
├── LICENSE
├── package.json
├── packages
│ ├── shared
│ │ ├── package.json
│ │ ├── src
│ │ │ ├── constants.ts
│ │ │ ├── index.ts
│ │ │ ├── tools.ts
│ │ │ └── types.ts
│ │ └── tsconfig.json
│ └── wasm-simd
│ ├── .gitignore
│ ├── BUILD.md
│ ├── Cargo.toml
│ ├── package.json
│ ├── README.md
│ └── src
│ └── lib.rs
├── pnpm-lock.yaml
├── pnpm-workspace.yaml
├── prompt
│ ├── content-analize.md
│ ├── excalidraw-prompt.md
│ └── modify-web.md
├── README_zh.md
├── README.md
├── releases
│ ├── chrome-extension
│ │ └── latest
│ │ └── chrome-mcp-server-lastest.zip
│ └── README.md
└── test-inject-script.js
```
# Files
--------------------------------------------------------------------------------
/app/chrome-extension/entrypoints/background/tools/browser/network-capture-web-request.ts:
--------------------------------------------------------------------------------
```typescript
import { createErrorResponse, ToolResult } from '@/common/tool-handler';
import { BaseBrowserToolExecutor } from '../base-browser';
import { TOOL_NAMES } from 'chrome-mcp-shared';
import { LIMITS, NETWORK_FILTERS } from '@/common/constants';
// Static resource file extensions
const STATIC_RESOURCE_EXTENSIONS = [
'.jpg',
'.jpeg',
'.png',
'.gif',
'.svg',
'.webp',
'.ico',
'.bmp', // Images
'.css',
'.scss',
'.less', // Styles
'.js',
'.jsx',
'.ts',
'.tsx', // Scripts
'.woff',
'.woff2',
'.ttf',
'.eot',
'.otf', // Fonts
'.mp3',
'.mp4',
'.avi',
'.mov',
'.wmv',
'.flv',
'.ogg',
'.wav', // Media
'.pdf',
'.doc',
'.docx',
'.xls',
'.xlsx',
'.ppt',
'.pptx', // Documents
];
// Ad and analytics domain list
const AD_ANALYTICS_DOMAINS = NETWORK_FILTERS.EXCLUDED_DOMAINS;
interface NetworkCaptureStartToolParams {
url?: string; // URL to navigate to or focus. If not provided, uses active tab.
maxCaptureTime?: number; // Maximum capture time (milliseconds)
inactivityTimeout?: number; // Inactivity timeout (milliseconds)
includeStatic?: boolean; // Whether to include static resources
}
interface NetworkRequestInfo {
requestId: string;
url: string;
method: string;
type: string;
requestTime: number;
requestHeaders?: Record<string, string>;
requestBody?: string;
responseHeaders?: Record<string, string>;
responseTime?: number;
status?: number;
statusText?: string;
responseSize?: number;
responseType?: string;
responseBody?: string;
errorText?: string;
specificRequestHeaders?: Record<string, string>;
specificResponseHeaders?: Record<string, string>;
mimeType?: string; // Response MIME type
}
interface CaptureInfo {
tabId: number;
tabUrl: string;
tabTitle: string;
startTime: number;
endTime?: number;
requests: Record<string, NetworkRequestInfo>;
maxCaptureTime: number;
inactivityTimeout: number;
includeStatic: boolean;
limitReached?: boolean; // Whether request count limit is reached
}
/**
* Network Capture Start Tool V2 - Uses Chrome webRequest API to start capturing network requests
*/
class NetworkCaptureStartTool extends BaseBrowserToolExecutor {
name = TOOL_NAMES.BROWSER.NETWORK_CAPTURE_START;
public static instance: NetworkCaptureStartTool | null = null;
public captureData: Map<number, CaptureInfo> = new Map(); // tabId -> capture data
private captureTimers: Map<number, NodeJS.Timeout> = new Map(); // tabId -> max capture timer
private inactivityTimers: Map<number, NodeJS.Timeout> = new Map(); // tabId -> inactivity timer
private lastActivityTime: Map<number, number> = new Map(); // tabId -> timestamp of last activity
private requestCounters: Map<number, number> = new Map(); // tabId -> count of captured requests
public static MAX_REQUESTS_PER_CAPTURE = LIMITS.MAX_NETWORK_REQUESTS; // Maximum capture request count
private listeners: { [key: string]: (details: any) => void } = {};
// Static resource MIME types list (for filtering)
private static STATIC_MIME_TYPES_TO_FILTER = [
'image/', // All image types
'font/', // All font types
'audio/', // All audio types
'video/', // All video types
'text/css',
'text/javascript',
'application/javascript',
'application/x-javascript',
'application/pdf',
'application/zip',
'application/octet-stream', // Usually for downloads or generic binary data
];
// API response MIME types list (these types are usually not filtered)
private static API_MIME_TYPES = [
'application/json',
'application/xml',
'text/xml',
'application/x-www-form-urlencoded',
'application/graphql',
'application/grpc',
'application/protobuf',
'application/x-protobuf',
'application/x-json',
'application/ld+json',
'application/problem+json',
'application/problem+xml',
'application/soap+xml',
'application/vnd.api+json',
];
constructor() {
super();
if (NetworkCaptureStartTool.instance) {
return NetworkCaptureStartTool.instance;
}
NetworkCaptureStartTool.instance = this;
// Listen for tab close events
chrome.tabs.onRemoved.addListener(this.handleTabRemoved.bind(this));
// Listen for tab creation events
chrome.tabs.onCreated.addListener(this.handleTabCreated.bind(this));
}
/**
* Handle tab close events
*/
private handleTabRemoved(tabId: number) {
if (this.captureData.has(tabId)) {
console.log(`NetworkCaptureV2: Tab ${tabId} was closed, cleaning up resources.`);
this.cleanupCapture(tabId);
}
}
/**
* Handle tab creation events
* If a new tab is opened from a tab being captured, automatically start capturing the new tab's requests
*/
private async handleTabCreated(tab: chrome.tabs.Tab) {
try {
// Check if there are any tabs currently capturing
if (this.captureData.size === 0) return;
// Get the openerTabId of the new tab (ID of the tab that opened this tab)
const openerTabId = tab.openerTabId;
if (!openerTabId) return;
// Check if the opener tab is currently capturing
if (!this.captureData.has(openerTabId)) return;
// Get the new tab's ID
const newTabId = tab.id;
if (!newTabId) return;
console.log(
`NetworkCaptureV2: New tab ${newTabId} created from capturing tab ${openerTabId}, will extend capture to it.`,
);
// Get the opener tab's capture settings
const openerCaptureInfo = this.captureData.get(openerTabId);
if (!openerCaptureInfo) return;
// Wait a short time to ensure the tab is ready
await new Promise((resolve) => setTimeout(resolve, 500));
// Start capturing requests for the new tab
await this.startCaptureForTab(newTabId, {
maxCaptureTime: openerCaptureInfo.maxCaptureTime,
inactivityTimeout: openerCaptureInfo.inactivityTimeout,
includeStatic: openerCaptureInfo.includeStatic,
});
console.log(`NetworkCaptureV2: Successfully extended capture to new tab ${newTabId}`);
} catch (error) {
console.error(`NetworkCaptureV2: Error extending capture to new tab:`, error);
}
}
/**
* Determine whether a request should be filtered (based on URL)
*/
private shouldFilterRequest(url: string, includeStatic: boolean): boolean {
try {
const urlObj = new URL(url);
// Check if it's an ad or analytics domain
if (AD_ANALYTICS_DOMAINS.some((domain) => urlObj.hostname.includes(domain))) {
console.log(`NetworkCaptureV2: Filtering ad/analytics domain: ${urlObj.hostname}`);
return true;
}
// If not including static resources, check extensions
if (!includeStatic) {
const path = urlObj.pathname.toLowerCase();
if (STATIC_RESOURCE_EXTENSIONS.some((ext) => path.endsWith(ext))) {
console.log(`NetworkCaptureV2: Filtering static resource by extension: ${path}`);
return true;
}
}
return false;
} catch (e) {
console.error('NetworkCaptureV2: Error filtering URL:', e);
return false;
}
}
/**
* Filter based on MIME type
*/
private shouldFilterByMimeType(mimeType: string, includeStatic: boolean): boolean {
if (!mimeType) return false;
// Always keep API response types
if (NetworkCaptureStartTool.API_MIME_TYPES.some((type) => mimeType.startsWith(type))) {
return false;
}
// If not including static resources, filter out static resource MIME types
if (!includeStatic) {
// Filter static resource MIME types
if (
NetworkCaptureStartTool.STATIC_MIME_TYPES_TO_FILTER.some((type) =>
mimeType.startsWith(type),
)
) {
console.log(`NetworkCaptureV2: Filtering static resource by MIME type: ${mimeType}`);
return true;
}
// Filter all MIME types starting with text/ (except those already in API_MIME_TYPES)
if (mimeType.startsWith('text/')) {
console.log(`NetworkCaptureV2: Filtering text response: ${mimeType}`);
return true;
}
}
return false;
}
/**
* Update last activity time and reset inactivity timer
*/
private updateLastActivityTime(tabId: number): void {
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) return;
this.lastActivityTime.set(tabId, Date.now());
// Reset inactivity timer
if (this.inactivityTimers.has(tabId)) {
clearTimeout(this.inactivityTimers.get(tabId)!);
}
if (captureInfo.inactivityTimeout > 0) {
this.inactivityTimers.set(
tabId,
setTimeout(() => this.checkInactivity(tabId), captureInfo.inactivityTimeout),
);
}
}
/**
* Check for inactivity
*/
private checkInactivity(tabId: number): void {
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) return;
const lastActivity = this.lastActivityTime.get(tabId) || captureInfo.startTime;
const now = Date.now();
const inactiveTime = now - lastActivity;
if (inactiveTime >= captureInfo.inactivityTimeout) {
console.log(
`NetworkCaptureV2: No activity for ${inactiveTime}ms, stopping capture for tab ${tabId}`,
);
this.stopCaptureByInactivity(tabId);
} else {
// If inactivity time hasn't been reached yet, continue checking
const remainingTime = captureInfo.inactivityTimeout - inactiveTime;
this.inactivityTimers.set(
tabId,
setTimeout(() => this.checkInactivity(tabId), remainingTime),
);
}
}
/**
* Stop capture due to inactivity
*/
private async stopCaptureByInactivity(tabId: number): Promise<void> {
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) return;
console.log(`NetworkCaptureV2: Stopping capture due to inactivity for tab ${tabId}`);
await this.stopCapture(tabId);
}
/**
* Clean up capture resources
*/
private cleanupCapture(tabId: number): void {
// Clear timers
if (this.captureTimers.has(tabId)) {
clearTimeout(this.captureTimers.get(tabId)!);
this.captureTimers.delete(tabId);
}
if (this.inactivityTimers.has(tabId)) {
clearTimeout(this.inactivityTimers.get(tabId)!);
this.inactivityTimers.delete(tabId);
}
// Remove data
this.lastActivityTime.delete(tabId);
this.captureData.delete(tabId);
this.requestCounters.delete(tabId);
console.log(`NetworkCaptureV2: Cleaned up all resources for tab ${tabId}`);
}
/**
* Set up request listeners
*/
private setupListeners(): void {
// Before request is sent
this.listeners.onBeforeRequest = (details: chrome.webRequest.WebRequestBodyDetails) => {
const captureInfo = this.captureData.get(details.tabId);
if (!captureInfo) return;
if (this.shouldFilterRequest(details.url, captureInfo.includeStatic)) {
return;
}
const currentCount = this.requestCounters.get(details.tabId) || 0;
if (currentCount >= NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE) {
console.log(
`NetworkCaptureV2: Request limit (${NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE}) reached for tab ${details.tabId}, ignoring new request: ${details.url}`,
);
captureInfo.limitReached = true;
return;
}
this.requestCounters.set(details.tabId, currentCount + 1);
this.updateLastActivityTime(details.tabId);
if (!captureInfo.requests[details.requestId]) {
captureInfo.requests[details.requestId] = {
requestId: details.requestId,
url: details.url,
method: details.method,
type: details.type,
requestTime: details.timeStamp,
};
if (details.requestBody) {
const requestBody = this.processRequestBody(details.requestBody);
if (requestBody) {
captureInfo.requests[details.requestId].requestBody = requestBody;
}
}
console.log(
`NetworkCaptureV2: Captured request ${currentCount + 1}/${NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE} for tab ${details.tabId}: ${details.method} ${details.url}`,
);
}
};
// Send request headers
this.listeners.onSendHeaders = (details: chrome.webRequest.WebRequestHeadersDetails) => {
const captureInfo = this.captureData.get(details.tabId);
if (!captureInfo || !captureInfo.requests[details.requestId]) return;
if (details.requestHeaders) {
const headers: Record<string, string> = {};
details.requestHeaders.forEach((header) => {
headers[header.name] = header.value || '';
});
captureInfo.requests[details.requestId].requestHeaders = headers;
}
};
// Receive response headers
this.listeners.onHeadersReceived = (details: chrome.webRequest.WebResponseHeadersDetails) => {
const captureInfo = this.captureData.get(details.tabId);
if (!captureInfo || !captureInfo.requests[details.requestId]) return;
const requestInfo = captureInfo.requests[details.requestId];
requestInfo.status = details.statusCode;
requestInfo.statusText = details.statusLine;
requestInfo.responseTime = details.timeStamp;
requestInfo.mimeType = details.responseHeaders?.find(
(h) => h.name.toLowerCase() === 'content-type',
)?.value;
// Secondary filtering based on MIME type
if (
requestInfo.mimeType &&
this.shouldFilterByMimeType(requestInfo.mimeType, captureInfo.includeStatic)
) {
delete captureInfo.requests[details.requestId];
const currentCount = this.requestCounters.get(details.tabId) || 0;
if (currentCount > 0) {
this.requestCounters.set(details.tabId, currentCount - 1);
}
console.log(
`NetworkCaptureV2: Filtered request by MIME type (${requestInfo.mimeType}): ${requestInfo.url}`,
);
return;
}
if (details.responseHeaders) {
const headers: Record<string, string> = {};
details.responseHeaders.forEach((header) => {
headers[header.name] = header.value || '';
});
requestInfo.responseHeaders = headers;
}
this.updateLastActivityTime(details.tabId);
};
// Request completed
this.listeners.onCompleted = (details: chrome.webRequest.WebResponseCacheDetails) => {
const captureInfo = this.captureData.get(details.tabId);
if (!captureInfo || !captureInfo.requests[details.requestId]) return;
const requestInfo = captureInfo.requests[details.requestId];
if ('responseSize' in details) {
requestInfo.responseSize = details.fromCache ? 0 : (details as any).responseSize;
}
this.updateLastActivityTime(details.tabId);
};
// Request failed
this.listeners.onErrorOccurred = (details: chrome.webRequest.WebResponseErrorDetails) => {
const captureInfo = this.captureData.get(details.tabId);
if (!captureInfo || !captureInfo.requests[details.requestId]) return;
const requestInfo = captureInfo.requests[details.requestId];
requestInfo.errorText = details.error;
this.updateLastActivityTime(details.tabId);
};
// Register all listeners
chrome.webRequest.onBeforeRequest.addListener(
this.listeners.onBeforeRequest,
{ urls: ['<all_urls>'] },
['requestBody'],
);
chrome.webRequest.onSendHeaders.addListener(
this.listeners.onSendHeaders,
{ urls: ['<all_urls>'] },
['requestHeaders'],
);
chrome.webRequest.onHeadersReceived.addListener(
this.listeners.onHeadersReceived,
{ urls: ['<all_urls>'] },
['responseHeaders'],
);
chrome.webRequest.onCompleted.addListener(this.listeners.onCompleted, { urls: ['<all_urls>'] });
chrome.webRequest.onErrorOccurred.addListener(this.listeners.onErrorOccurred, {
urls: ['<all_urls>'],
});
}
/**
* Remove all request listeners
* Only remove listeners when all tab captures have stopped
*/
private removeListeners(): void {
// Don't remove listeners if there are still tabs being captured
if (this.captureData.size > 0) {
console.log(
`NetworkCaptureV2: Still capturing on ${this.captureData.size} tabs, not removing listeners.`,
);
return;
}
console.log(`NetworkCaptureV2: No more active captures, removing all listeners.`);
if (this.listeners.onBeforeRequest) {
chrome.webRequest.onBeforeRequest.removeListener(this.listeners.onBeforeRequest);
}
if (this.listeners.onSendHeaders) {
chrome.webRequest.onSendHeaders.removeListener(this.listeners.onSendHeaders);
}
if (this.listeners.onHeadersReceived) {
chrome.webRequest.onHeadersReceived.removeListener(this.listeners.onHeadersReceived);
}
if (this.listeners.onCompleted) {
chrome.webRequest.onCompleted.removeListener(this.listeners.onCompleted);
}
if (this.listeners.onErrorOccurred) {
chrome.webRequest.onErrorOccurred.removeListener(this.listeners.onErrorOccurred);
}
// Clear listener object
this.listeners = {};
}
/**
* Process request body data
*/
private processRequestBody(requestBody: chrome.webRequest.WebRequestBody): string | undefined {
if (requestBody.raw && requestBody.raw.length > 0) {
return '[Binary data]';
} else if (requestBody.formData) {
return JSON.stringify(requestBody.formData);
}
return undefined;
}
/**
* Start network request capture for specified tab
* @param tabId Tab ID
* @param options Capture options
*/
private async startCaptureForTab(
tabId: number,
options: {
maxCaptureTime: number;
inactivityTimeout: number;
includeStatic: boolean;
},
): Promise<void> {
const { maxCaptureTime, inactivityTimeout, includeStatic } = options;
// If already capturing, stop first
if (this.captureData.has(tabId)) {
console.log(
`NetworkCaptureV2: Already capturing on tab ${tabId}. Stopping previous session.`,
);
await this.stopCapture(tabId);
}
try {
// Get tab information
const tab = await chrome.tabs.get(tabId);
// Initialize capture data
this.captureData.set(tabId, {
tabId: tabId,
tabUrl: tab.url || '',
tabTitle: tab.title || '',
startTime: Date.now(),
requests: {},
maxCaptureTime,
inactivityTimeout,
includeStatic,
limitReached: false,
});
// Initialize request counter
this.requestCounters.set(tabId, 0);
// Set up listeners
this.setupListeners();
// Update last activity time
this.updateLastActivityTime(tabId);
console.log(
`NetworkCaptureV2: Started capture for tab ${tabId} (${tab.url}). Max requests: ${NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE}, Max time: ${maxCaptureTime}ms, Inactivity: ${inactivityTimeout}ms.`,
);
// Set maximum capture time
if (maxCaptureTime > 0) {
this.captureTimers.set(
tabId,
setTimeout(async () => {
console.log(
`NetworkCaptureV2: Max capture time (${maxCaptureTime}ms) reached for tab ${tabId}.`,
);
await this.stopCapture(tabId);
}, maxCaptureTime),
);
}
} catch (error: any) {
console.error(`NetworkCaptureV2: Error starting capture for tab ${tabId}:`, error);
// Clean up resources
if (this.captureData.has(tabId)) {
this.cleanupCapture(tabId);
}
throw error;
}
}
/**
* Stop capture
* @param tabId Tab ID
*/
public async stopCapture(
tabId: number,
): Promise<{ success: boolean; message?: string; data?: any }> {
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) {
console.log(`NetworkCaptureV2: No capture in progress for tab ${tabId}`);
return { success: false, message: `No capture in progress for tab ${tabId}` };
}
try {
// Record end time
captureInfo.endTime = Date.now();
// Extract common request and response headers
const requestsArray = Object.values(captureInfo.requests);
const commonRequestHeaders = this.analyzeCommonHeaders(requestsArray, 'requestHeaders');
const commonResponseHeaders = this.analyzeCommonHeaders(requestsArray, 'responseHeaders');
// Process request data, remove common headers
const processedRequests = requestsArray.map((req) => {
const finalReq: NetworkRequestInfo = { ...req };
if (finalReq.requestHeaders) {
finalReq.specificRequestHeaders = this.filterOutCommonHeaders(
finalReq.requestHeaders,
commonRequestHeaders,
);
delete finalReq.requestHeaders;
} else {
finalReq.specificRequestHeaders = {};
}
if (finalReq.responseHeaders) {
finalReq.specificResponseHeaders = this.filterOutCommonHeaders(
finalReq.responseHeaders,
commonResponseHeaders,
);
delete finalReq.responseHeaders;
} else {
finalReq.specificResponseHeaders = {};
}
return finalReq;
});
// Sort by time
processedRequests.sort((a, b) => (a.requestTime || 0) - (b.requestTime || 0));
// Remove listeners
this.removeListeners();
// Prepare result data
const resultData = {
captureStartTime: captureInfo.startTime,
captureEndTime: captureInfo.endTime,
totalDurationMs: captureInfo.endTime - captureInfo.startTime,
settingsUsed: {
maxCaptureTime: captureInfo.maxCaptureTime,
inactivityTimeout: captureInfo.inactivityTimeout,
includeStatic: captureInfo.includeStatic,
maxRequests: NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE,
},
commonRequestHeaders,
commonResponseHeaders,
requests: processedRequests,
requestCount: processedRequests.length,
totalRequestsReceived: this.requestCounters.get(tabId) || 0,
requestLimitReached: captureInfo.limitReached || false,
tabUrl: captureInfo.tabUrl,
tabTitle: captureInfo.tabTitle,
};
// Clean up resources
this.cleanupCapture(tabId);
return {
success: true,
data: resultData,
};
} catch (error: any) {
console.error(`NetworkCaptureV2: Error stopping capture for tab ${tabId}:`, error);
// Ensure resources are cleaned up
this.cleanupCapture(tabId);
return {
success: false,
message: `Error stopping capture: ${error.message || String(error)}`,
};
}
}
/**
* Analyze common request or response headers
*/
private analyzeCommonHeaders(
requests: NetworkRequestInfo[],
headerType: 'requestHeaders' | 'responseHeaders',
): Record<string, string> {
if (!requests || requests.length === 0) return {};
// Find headers that are included in all requests
const commonHeaders: Record<string, string> = {};
const firstRequestWithHeaders = requests.find(
(req) => req[headerType] && Object.keys(req[headerType] || {}).length > 0,
);
if (!firstRequestWithHeaders || !firstRequestWithHeaders[headerType]) {
return {};
}
// Get all headers from the first request
const headers = firstRequestWithHeaders[headerType] as Record<string, string>;
const headerNames = Object.keys(headers);
// Check if each header exists in all requests with the same value
for (const name of headerNames) {
const value = headers[name];
const isCommon = requests.every((req) => {
const reqHeaders = req[headerType] as Record<string, string>;
return reqHeaders && reqHeaders[name] === value;
});
if (isCommon) {
commonHeaders[name] = value;
}
}
return commonHeaders;
}
/**
* Filter out common headers
*/
private filterOutCommonHeaders(
headers: Record<string, string>,
commonHeaders: Record<string, string>,
): Record<string, string> {
if (!headers || typeof headers !== 'object') return {};
const specificHeaders: Record<string, string> = {};
// Use Object.keys to avoid ESLint no-prototype-builtins warning
Object.keys(headers).forEach((name) => {
if (!(name in commonHeaders) || headers[name] !== commonHeaders[name]) {
specificHeaders[name] = headers[name];
}
});
return specificHeaders;
}
async execute(args: NetworkCaptureStartToolParams): Promise<ToolResult> {
const {
url: targetUrl,
maxCaptureTime = 3 * 60 * 1000, // Default 3 minutes
inactivityTimeout = 60 * 1000, // Default 1 minute of inactivity before auto-stop
includeStatic = false, // Default: don't include static resources
} = args;
console.log(`NetworkCaptureStartTool: Executing with args:`, args);
try {
// Get current tab or create new tab
let tabToOperateOn: chrome.tabs.Tab;
if (targetUrl) {
// Find tabs matching the URL
const matchingTabs = await chrome.tabs.query({ url: targetUrl });
if (matchingTabs.length > 0) {
// Use existing tab
tabToOperateOn = matchingTabs[0];
console.log(`NetworkCaptureV2: Found existing tab with URL: ${targetUrl}`);
} else {
// Create new tab
console.log(`NetworkCaptureV2: Creating new tab with URL: ${targetUrl}`);
tabToOperateOn = await chrome.tabs.create({ url: targetUrl, active: true });
// Wait for page to load
await new Promise((resolve) => setTimeout(resolve, 1000));
}
} else {
// Use current active tab
const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
if (!tabs[0]) {
return createErrorResponse('No active tab found');
}
tabToOperateOn = tabs[0];
}
if (!tabToOperateOn?.id) {
return createErrorResponse('Failed to identify or create a tab');
}
// Use startCaptureForTab method to start capture
try {
await this.startCaptureForTab(tabToOperateOn.id, {
maxCaptureTime,
inactivityTimeout,
includeStatic,
});
} catch (error: any) {
return createErrorResponse(
`Failed to start capture for tab ${tabToOperateOn.id}: ${error.message || String(error)}`,
);
}
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
message: 'Network capture V2 started successfully, waiting for stop command.',
tabId: tabToOperateOn.id,
url: tabToOperateOn.url,
maxCaptureTime,
inactivityTimeout,
includeStatic,
maxRequests: NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE,
}),
},
],
isError: false,
};
} catch (error: any) {
console.error('NetworkCaptureStartTool: Critical error:', error);
return createErrorResponse(
`Error in NetworkCaptureStartTool: ${error.message || String(error)}`,
);
}
}
}
/**
* Network capture stop tool V2 - Stop webRequest API capture and return results
*/
class NetworkCaptureStopTool extends BaseBrowserToolExecutor {
name = TOOL_NAMES.BROWSER.NETWORK_CAPTURE_STOP;
public static instance: NetworkCaptureStopTool | null = null;
constructor() {
super();
if (NetworkCaptureStopTool.instance) {
return NetworkCaptureStopTool.instance;
}
NetworkCaptureStopTool.instance = this;
}
async execute(): Promise<ToolResult> {
console.log(`NetworkCaptureStopTool: Executing`);
try {
const startTool = NetworkCaptureStartTool.instance;
if (!startTool) {
return createErrorResponse('Network capture V2 start tool instance not found');
}
// Get all tabs currently capturing
const ongoingCaptures = Array.from(startTool.captureData.keys());
console.log(
`NetworkCaptureStopTool: Found ${ongoingCaptures.length} ongoing captures: ${ongoingCaptures.join(', ')}`,
);
if (ongoingCaptures.length === 0) {
return createErrorResponse('No active network captures found in any tab.');
}
// Get current active tab
const activeTabs = await chrome.tabs.query({ active: true, currentWindow: true });
const activeTabId = activeTabs[0]?.id;
// Determine the primary tab to stop
let primaryTabId: number;
if (activeTabId && startTool.captureData.has(activeTabId)) {
// If current active tab is capturing, prioritize stopping it
primaryTabId = activeTabId;
console.log(
`NetworkCaptureStopTool: Active tab ${activeTabId} is capturing, will stop it first.`,
);
} else if (ongoingCaptures.length === 1) {
// If only one tab is capturing, stop it
primaryTabId = ongoingCaptures[0];
console.log(
`NetworkCaptureStopTool: Only one tab ${primaryTabId} is capturing, stopping it.`,
);
} else {
// If multiple tabs are capturing but current active tab is not among them, stop the first one
primaryTabId = ongoingCaptures[0];
console.log(
`NetworkCaptureStopTool: Multiple tabs capturing, active tab not among them. Stopping tab ${primaryTabId} first.`,
);
}
const stopResult = await startTool.stopCapture(primaryTabId);
if (!stopResult.success) {
return createErrorResponse(
stopResult.message || `Failed to stop network capture for tab ${primaryTabId}`,
);
}
// If multiple tabs are capturing, stop other tabs
if (ongoingCaptures.length > 1) {
const otherTabIds = ongoingCaptures.filter((id) => id !== primaryTabId);
console.log(
`NetworkCaptureStopTool: Stopping ${otherTabIds.length} additional captures: ${otherTabIds.join(', ')}`,
);
for (const tabId of otherTabIds) {
try {
await startTool.stopCapture(tabId);
} catch (error) {
console.error(`NetworkCaptureStopTool: Error stopping capture on tab ${tabId}:`, error);
}
}
}
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
message: `Capture complete. ${stopResult.data?.requestCount || 0} requests captured.`,
tabId: primaryTabId,
tabUrl: stopResult.data?.tabUrl || 'N/A',
tabTitle: stopResult.data?.tabTitle || 'Unknown Tab',
requestCount: stopResult.data?.requestCount || 0,
commonRequestHeaders: stopResult.data?.commonRequestHeaders || {},
commonResponseHeaders: stopResult.data?.commonResponseHeaders || {},
requests: stopResult.data?.requests || [],
captureStartTime: stopResult.data?.captureStartTime,
captureEndTime: stopResult.data?.captureEndTime,
totalDurationMs: stopResult.data?.totalDurationMs,
settingsUsed: stopResult.data?.settingsUsed || {},
totalRequestsReceived: stopResult.data?.totalRequestsReceived || 0,
requestLimitReached: stopResult.data?.requestLimitReached || false,
remainingCaptures: Array.from(startTool.captureData.keys()),
}),
},
],
isError: false,
};
} catch (error: any) {
console.error('NetworkCaptureStopTool: Critical error:', error);
return createErrorResponse(
`Error in NetworkCaptureStopTool: ${error.message || String(error)}`,
);
}
}
}
export const networkCaptureStartTool = new NetworkCaptureStartTool();
export const networkCaptureStopTool = new NetworkCaptureStopTool();
```
--------------------------------------------------------------------------------
/app/chrome-extension/entrypoints/background/tools/browser/network-capture-debugger.ts:
--------------------------------------------------------------------------------
```typescript
import { createErrorResponse, ToolResult } from '@/common/tool-handler';
import { BaseBrowserToolExecutor } from '../base-browser';
import { TOOL_NAMES } from 'chrome-mcp-shared';
interface NetworkDebuggerStartToolParams {
url?: string; // URL to navigate to or focus. If not provided, uses active tab.
maxCaptureTime?: number;
inactivityTimeout?: number; // Inactivity timeout (milliseconds)
includeStatic?: boolean; // if include static resources
}
// Network request object interface
interface NetworkRequestInfo {
requestId: string;
url: string;
method: string;
requestHeaders?: Record<string, string>; // Will be removed after common headers extraction
responseHeaders?: Record<string, string>; // Will be removed after common headers extraction
requestTime?: number; // Timestamp of the request
responseTime?: number; // Timestamp of the response
type: string; // Resource type (e.g., Document, XHR, Fetch, Script, Stylesheet)
status: string; // 'pending', 'complete', 'error'
statusCode?: number;
statusText?: string;
requestBody?: string;
responseBody?: string;
base64Encoded?: boolean; // For responseBody
encodedDataLength?: number; // Actual bytes received
errorText?: string; // If loading failed
canceled?: boolean; // If loading was canceled
mimeType?: string;
specificRequestHeaders?: Record<string, string>; // Headers unique to this request
specificResponseHeaders?: Record<string, string>; // Headers unique to this response
[key: string]: any; // Allow other properties from debugger events
}
// Static resource file extensions list
const STATIC_RESOURCE_EXTENSIONS = [
'.png',
'.jpg',
'.jpeg',
'.gif',
'.bmp',
'.webp',
'.svg',
'.ico',
'.cur',
'.css',
'.woff',
'.woff2',
'.ttf',
'.eot',
'.otf',
'.mp3',
'.mp4',
'.avi',
'.mov',
'.webm',
'.ogg',
'.wav',
'.pdf',
'.zip',
'.rar',
'.7z',
'.iso',
'.dmg',
'.js',
'.jsx',
'.ts',
'.tsx',
'.map', // Source maps
];
// Ad and analytics domains list
const AD_ANALYTICS_DOMAINS = [
'google-analytics.com',
'googletagmanager.com',
'analytics.google.com',
'doubleclick.net',
'googlesyndication.com',
'googleads.g.doubleclick.net',
'facebook.com/tr',
'connect.facebook.net',
'bat.bing.com',
'linkedin.com', // Often for tracking pixels/insights
'analytics.twitter.com',
'static.hotjar.com',
'script.hotjar.com',
'stats.g.doubleclick.net',
'amazon-adsystem.com',
'adservice.google.com',
'pagead2.googlesyndication.com',
'ads-twitter.com',
'ads.yahoo.com',
'adroll.com',
'adnxs.com',
'criteo.com',
'quantserve.com',
'scorecardresearch.com',
'segment.io',
'amplitude.com',
'mixpanel.com',
'optimizely.com',
'crazyegg.com',
'clicktale.net',
'mouseflow.com',
'fullstory.com',
'clarity.ms',
];
const DEBUGGER_PROTOCOL_VERSION = '1.3';
const MAX_RESPONSE_BODY_SIZE_BYTES = 1 * 1024 * 1024; // 1MB
const DEFAULT_MAX_CAPTURE_TIME_MS = 3 * 60 * 1000; // 3 minutes
const DEFAULT_INACTIVITY_TIMEOUT_MS = 60 * 1000; // 1 minute
/**
* Network capture start tool - uses Chrome Debugger API to start capturing network requests
*/
class NetworkDebuggerStartTool extends BaseBrowserToolExecutor {
name = TOOL_NAMES.BROWSER.NETWORK_DEBUGGER_START;
private captureData: Map<number, any> = new Map(); // tabId -> capture data
private captureTimers: Map<number, NodeJS.Timeout> = new Map(); // tabId -> max capture timer
private inactivityTimers: Map<number, NodeJS.Timeout> = new Map(); // tabId -> inactivity timer
private lastActivityTime: Map<number, number> = new Map(); // tabId -> timestamp of last network activity
private pendingResponseBodies: Map<string, Promise<any>> = new Map(); // requestId -> promise for getResponseBody
private requestCounters: Map<number, number> = new Map(); // tabId -> count of captured requests (after filtering)
private static MAX_REQUESTS_PER_CAPTURE = 100; // Max requests to store to prevent memory issues
public static instance: NetworkDebuggerStartTool | null = null;
constructor() {
super();
if (NetworkDebuggerStartTool.instance) {
return NetworkDebuggerStartTool.instance;
}
NetworkDebuggerStartTool.instance = this;
chrome.debugger.onEvent.addListener(this.handleDebuggerEvent.bind(this));
chrome.debugger.onDetach.addListener(this.handleDebuggerDetach.bind(this));
chrome.tabs.onRemoved.addListener(this.handleTabRemoved.bind(this));
chrome.tabs.onCreated.addListener(this.handleTabCreated.bind(this));
}
private handleTabRemoved(tabId: number) {
if (this.captureData.has(tabId)) {
console.log(`NetworkDebuggerStartTool: Tab ${tabId} was closed, cleaning up resources.`);
this.cleanupCapture(tabId);
}
}
/**
* Handle tab creation events
* If a new tab is opened from a tab that is currently capturing, automatically start capturing the new tab's requests
*/
private async handleTabCreated(tab: chrome.tabs.Tab) {
try {
// Check if there are any tabs currently capturing
if (this.captureData.size === 0) return;
// Get the openerTabId of the new tab (ID of the tab that opened this tab)
const openerTabId = tab.openerTabId;
if (!openerTabId) return;
// Check if the opener tab is currently capturing
if (!this.captureData.has(openerTabId)) return;
// Get the new tab's ID
const newTabId = tab.id;
if (!newTabId) return;
console.log(
`NetworkDebuggerStartTool: New tab ${newTabId} created from capturing tab ${openerTabId}, will extend capture to it.`,
);
// Get the opener tab's capture settings
const openerCaptureInfo = this.captureData.get(openerTabId);
if (!openerCaptureInfo) return;
// Wait a short time to ensure the tab is ready
await new Promise((resolve) => setTimeout(resolve, 500));
// Start capturing requests for the new tab
await this.startCaptureForTab(newTabId, {
maxCaptureTime: openerCaptureInfo.maxCaptureTime,
inactivityTimeout: openerCaptureInfo.inactivityTimeout,
includeStatic: openerCaptureInfo.includeStatic,
});
console.log(`NetworkDebuggerStartTool: Successfully extended capture to new tab ${newTabId}`);
} catch (error) {
console.error(`NetworkDebuggerStartTool: Error extending capture to new tab:`, error);
}
}
/**
* Start network request capture for specified tab
* @param tabId Tab ID
* @param options Capture options
*/
private async startCaptureForTab(
tabId: number,
options: {
maxCaptureTime: number;
inactivityTimeout: number;
includeStatic: boolean;
},
): Promise<void> {
const { maxCaptureTime, inactivityTimeout, includeStatic } = options;
// If already capturing, stop first
if (this.captureData.has(tabId)) {
console.log(
`NetworkDebuggerStartTool: Already capturing on tab ${tabId}. Stopping previous session.`,
);
await this.stopCapture(tabId);
}
try {
// Get tab information
const tab = await chrome.tabs.get(tabId);
// Check if debugger is already attached
const targets = await chrome.debugger.getTargets();
const existingTarget = targets.find(
(t) => t.tabId === tabId && t.attached && t.type === 'page',
);
if (existingTarget && !existingTarget.extensionId) {
throw new Error(
`Debugger is already attached to tab ${tabId} by another tool (e.g., DevTools).`,
);
}
// Attach debugger
try {
await chrome.debugger.attach({ tabId }, DEBUGGER_PROTOCOL_VERSION);
} catch (error: any) {
if (error.message?.includes('Cannot attach to the target with an attached client')) {
throw new Error(
`Debugger is already attached to tab ${tabId}. This might be DevTools or another extension.`,
);
}
throw error;
}
// Enable network tracking
try {
await chrome.debugger.sendCommand({ tabId }, 'Network.enable');
} catch (error: any) {
await chrome.debugger
.detach({ tabId })
.catch((e) => console.warn('Error detaching after failed enable:', e));
throw error;
}
// Initialize capture data
this.captureData.set(tabId, {
startTime: Date.now(),
tabUrl: tab.url,
tabTitle: tab.title,
maxCaptureTime,
inactivityTimeout,
includeStatic,
requests: {},
limitReached: false,
});
// Initialize request counter
this.requestCounters.set(tabId, 0);
// Update last activity time
this.updateLastActivityTime(tabId);
console.log(
`NetworkDebuggerStartTool: Started capture for tab ${tabId} (${tab.url}). Max requests: ${NetworkDebuggerStartTool.MAX_REQUESTS_PER_CAPTURE}, Max time: ${maxCaptureTime}ms, Inactivity: ${inactivityTimeout}ms.`,
);
// Set maximum capture time
if (maxCaptureTime > 0) {
this.captureTimers.set(
tabId,
setTimeout(async () => {
console.log(
`NetworkDebuggerStartTool: Max capture time (${maxCaptureTime}ms) reached for tab ${tabId}.`,
);
await this.stopCapture(tabId, true); // Auto-stop due to max time
}, maxCaptureTime),
);
}
} catch (error: any) {
console.error(`NetworkDebuggerStartTool: Error starting capture for tab ${tabId}:`, error);
// Clean up resources
if (this.captureData.has(tabId)) {
await chrome.debugger
.detach({ tabId })
.catch((e) => console.warn('Cleanup detach error:', e));
this.cleanupCapture(tabId);
}
throw error;
}
}
private handleDebuggerEvent(source: chrome.debugger.Debuggee, method: string, params?: any) {
if (!source.tabId) return;
const tabId = source.tabId;
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) return; // Not capturing for this tab
// Update last activity time for any relevant network event
this.updateLastActivityTime(tabId);
switch (method) {
case 'Network.requestWillBeSent':
this.handleRequestWillBeSent(tabId, params);
break;
case 'Network.responseReceived':
this.handleResponseReceived(tabId, params);
break;
case 'Network.loadingFinished':
this.handleLoadingFinished(tabId, params);
break;
case 'Network.loadingFailed':
this.handleLoadingFailed(tabId, params);
break;
}
}
private handleDebuggerDetach(source: chrome.debugger.Debuggee, reason: string) {
if (source.tabId && this.captureData.has(source.tabId)) {
console.log(
`NetworkDebuggerStartTool: Debugger detached from tab ${source.tabId}, reason: ${reason}. Cleaning up.`,
);
// Potentially inform the user or log the result if the detachment was unexpected
this.cleanupCapture(source.tabId); // Ensure cleanup happens
}
}
private updateLastActivityTime(tabId: number) {
this.lastActivityTime.set(tabId, Date.now());
const captureInfo = this.captureData.get(tabId);
if (captureInfo && captureInfo.inactivityTimeout > 0) {
if (this.inactivityTimers.has(tabId)) {
clearTimeout(this.inactivityTimers.get(tabId)!);
}
this.inactivityTimers.set(
tabId,
setTimeout(() => this.checkInactivity(tabId), captureInfo.inactivityTimeout),
);
}
}
private checkInactivity(tabId: number) {
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) return;
const lastActivity = this.lastActivityTime.get(tabId) || captureInfo.startTime; // Use startTime if no activity yet
const now = Date.now();
const inactiveTime = now - lastActivity;
if (inactiveTime >= captureInfo.inactivityTimeout) {
console.log(
`NetworkDebuggerStartTool: No activity for ${inactiveTime}ms (threshold: ${captureInfo.inactivityTimeout}ms), stopping capture for tab ${tabId}`,
);
this.stopCaptureByInactivity(tabId);
} else {
// Reschedule check for the remaining time, this handles system sleep or other interruptions
const remainingTime = Math.max(0, captureInfo.inactivityTimeout - inactiveTime);
this.inactivityTimers.set(
tabId,
setTimeout(() => this.checkInactivity(tabId), remainingTime),
);
}
}
private async stopCaptureByInactivity(tabId: number) {
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) return;
console.log(`NetworkDebuggerStartTool: Stopping capture due to inactivity for tab ${tabId}.`);
// Potentially, we might want to notify the client/user that this happened.
// For now, just stop and make the results available if StopTool is called.
await this.stopCapture(tabId, true); // Pass a flag indicating it's an auto-stop
}
// Static resource MIME types list (used when includeStatic is false)
private static STATIC_MIME_TYPES_TO_FILTER = [
'image/', // all image types (image/png, image/jpeg, etc.)
'font/', // all font types (font/woff, font/ttf, etc.)
'audio/', // all audio types
'video/', // all video types
'text/css',
// Note: text/javascript, application/javascript etc. are often filtered by extension.
// If script files need to be filtered by MIME type as well, add them here.
// 'application/javascript',
// 'application/x-javascript',
'application/pdf',
'application/zip',
'application/octet-stream', // Often used for downloads or generic binary data
];
// API-like response MIME types (these are generally NOT filtered, and we might want their bodies)
private static API_MIME_TYPES = [
'application/json',
'application/xml',
'text/xml',
// 'text/json' is not standard, but sometimes seen. 'application/json' is preferred.
'text/plain', // Can be API response, handle with care. Often captured.
'application/x-www-form-urlencoded', // Form submissions, can be API calls
'application/graphql',
// Add other common API types if needed
];
private shouldFilterRequestByUrl(url: string): boolean {
try {
const urlObj = new URL(url);
// Filter ad/analytics domains
if (AD_ANALYTICS_DOMAINS.some((domain) => urlObj.hostname.includes(domain))) {
// console.log(`NetworkDebuggerStartTool: Filtering ad/analytics domain: ${urlObj.hostname}`);
return true;
}
return false;
} catch (e) {
// Invalid URL? Log and don't filter.
console.error(`NetworkDebuggerStartTool: Error parsing URL for filtering: ${url}`, e);
return false;
}
}
private shouldFilterRequestByExtension(url: string, includeStatic: boolean): boolean {
if (includeStatic) return false; // If including static, don't filter by extension
try {
const urlObj = new URL(url);
const path = urlObj.pathname.toLowerCase();
if (STATIC_RESOURCE_EXTENSIONS.some((ext) => path.endsWith(ext))) {
// console.log(`NetworkDebuggerStartTool: Filtering static resource by extension: ${path}`);
return true;
}
return false;
} catch (e) {
console.error(
`NetworkDebuggerStartTool: Error parsing URL for extension filtering: ${url}`,
e,
);
return false;
}
}
// MIME type-based filtering, called after response is received
private shouldFilterByMimeType(mimeType: string, includeStatic: boolean): boolean {
if (!mimeType) return false; // No MIME type, don't make a decision based on it here
// If API_MIME_TYPES contains this mimeType, we explicitly DON'T want to filter it by MIME.
if (NetworkDebuggerStartTool.API_MIME_TYPES.some((apiMime) => mimeType.startsWith(apiMime))) {
return false;
}
// If we are NOT including static files, then check against the list of static MIME types.
if (!includeStatic) {
if (
NetworkDebuggerStartTool.STATIC_MIME_TYPES_TO_FILTER.some((staticMime) =>
mimeType.startsWith(staticMime),
)
) {
// console.log(`NetworkDebuggerStartTool: Filtering static resource by MIME type: ${mimeType}`);
return true;
}
}
// Default: don't filter by MIME type if no other rule matched
return false;
}
private handleRequestWillBeSent(tabId: number, params: any) {
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) return;
const { requestId, request, timestamp, type, loaderId, frameId } = params;
// Initial filtering by URL (ads, analytics) and extension (if !includeStatic)
if (
this.shouldFilterRequestByUrl(request.url) ||
this.shouldFilterRequestByExtension(request.url, captureInfo.includeStatic)
) {
return;
}
const currentCount = this.requestCounters.get(tabId) || 0;
if (currentCount >= NetworkDebuggerStartTool.MAX_REQUESTS_PER_CAPTURE) {
// console.log(`NetworkDebuggerStartTool: Request limit (${NetworkDebuggerStartTool.MAX_REQUESTS_PER_CAPTURE}) reached for tab ${tabId}. Ignoring: ${request.url}`);
captureInfo.limitReached = true; // Mark that limit was hit
return;
}
// Store initial request info
// Ensure we don't overwrite if a redirect (same requestId) occurred, though usually loaderId changes
if (!captureInfo.requests[requestId]) {
// Or check based on loaderId as well if needed
captureInfo.requests[requestId] = {
requestId,
url: request.url,
method: request.method,
requestHeaders: request.headers, // Temporary, will be processed
requestTime: timestamp * 1000, // Convert seconds to milliseconds
type: type || 'Other',
status: 'pending', // Initial status
loaderId, // Useful for tracking redirects
frameId, // Useful for context
};
if (request.postData) {
captureInfo.requests[requestId].requestBody = request.postData;
}
// console.log(`NetworkDebuggerStartTool: Captured request for tab ${tabId}: ${request.method} ${request.url}`);
} else {
// This could be a redirect. Update URL and other relevant fields.
// Chrome often issues a new `requestWillBeSent` for redirects with the same `requestId` but a new `loaderId`.
// console.log(`NetworkDebuggerStartTool: Request ${requestId} updated (likely redirect) for tab ${tabId} to URL: ${request.url}`);
const existingRequest = captureInfo.requests[requestId];
existingRequest.url = request.url; // Update URL due to redirect
existingRequest.requestTime = timestamp * 1000; // Update time for the redirected request
if (request.headers) existingRequest.requestHeaders = request.headers;
if (request.postData) existingRequest.requestBody = request.postData;
else delete existingRequest.requestBody;
}
}
private handleResponseReceived(tabId: number, params: any) {
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) return;
const { requestId, response, timestamp, type } = params; // type here is resource type
const requestInfo: NetworkRequestInfo = captureInfo.requests[requestId];
if (!requestInfo) {
// console.warn(`NetworkDebuggerStartTool: Received response for unknown requestId ${requestId} on tab ${tabId}`);
return;
}
// Secondary filtering based on MIME type, now that we have it
if (this.shouldFilterByMimeType(response.mimeType, captureInfo.includeStatic)) {
// console.log(`NetworkDebuggerStartTool: Filtering request by MIME type (${response.mimeType}): ${requestInfo.url}`);
delete captureInfo.requests[requestId]; // Remove from captured data
// Note: We don't decrement requestCounter here as it's meant to track how many *potential* requests were processed up to MAX_REQUESTS.
// Or, if MAX_REQUESTS is strictly for *stored* requests, then decrement. For now, let's assume it's for stored.
// const currentCount = this.requestCounters.get(tabId) || 0;
// if (currentCount > 0) this.requestCounters.set(tabId, currentCount -1);
return;
}
// If not filtered by MIME, then increment actual stored request counter
const currentStoredCount = Object.keys(captureInfo.requests).length; // A bit inefficient but accurate
this.requestCounters.set(tabId, currentStoredCount);
requestInfo.status = response.status === 0 ? 'pending' : 'complete'; // status 0 can mean pending or blocked
requestInfo.statusCode = response.status;
requestInfo.statusText = response.statusText;
requestInfo.responseHeaders = response.headers; // Temporary
requestInfo.mimeType = response.mimeType;
requestInfo.responseTime = timestamp * 1000; // Convert seconds to milliseconds
if (type) requestInfo.type = type; // Update resource type if provided by this event
// console.log(`NetworkDebuggerStartTool: Received response for ${requestId} on tab ${tabId}: ${response.status}`);
}
private async handleLoadingFinished(tabId: number, params: any) {
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) return;
const { requestId, encodedDataLength } = params;
const requestInfo: NetworkRequestInfo = captureInfo.requests[requestId];
if (!requestInfo) {
// console.warn(`NetworkDebuggerStartTool: LoadingFinished for unknown requestId ${requestId} on tab ${tabId}`);
return;
}
requestInfo.encodedDataLength = encodedDataLength;
if (requestInfo.status === 'pending') requestInfo.status = 'complete'; // Mark as complete if not already
// requestInfo.responseTime is usually set by responseReceived, but this timestamp is later.
// timestamp here is when the resource finished loading. Could be useful for duration calculation.
if (this.shouldCaptureResponseBody(requestInfo)) {
try {
// console.log(`NetworkDebuggerStartTool: Attempting to get response body for ${requestId} (${requestInfo.url})`);
const responseBodyData = await this.getResponseBody(tabId, requestId);
if (responseBodyData) {
if (
responseBodyData.body &&
responseBodyData.body.length > MAX_RESPONSE_BODY_SIZE_BYTES
) {
requestInfo.responseBody =
responseBodyData.body.substring(0, MAX_RESPONSE_BODY_SIZE_BYTES) +
`\n\n... [Response truncated, total size: ${responseBodyData.body.length} bytes] ...`;
} else {
requestInfo.responseBody = responseBodyData.body;
}
requestInfo.base64Encoded = responseBodyData.base64Encoded;
// console.log(`NetworkDebuggerStartTool: Successfully got response body for ${requestId}, size: ${requestInfo.responseBody?.length || 0} bytes`);
}
} catch (error) {
// console.warn(`NetworkDebuggerStartTool: Failed to get response body for ${requestId}:`, error);
requestInfo.errorText =
(requestInfo.errorText || '') +
` Failed to get body: ${error instanceof Error ? error.message : String(error)}`;
}
}
}
private shouldCaptureResponseBody(requestInfo: NetworkRequestInfo): boolean {
const mimeType = requestInfo.mimeType || '';
// Prioritize API MIME types for body capture
if (NetworkDebuggerStartTool.API_MIME_TYPES.some((type) => mimeType.startsWith(type))) {
return true;
}
// Heuristics for other potential API calls not perfectly matching MIME types
const url = requestInfo.url.toLowerCase();
if (
/\/(api|service|rest|graphql|query|data|rpc|v[0-9]+)\//i.test(url) ||
url.includes('.json') ||
url.includes('json=') ||
url.includes('format=json')
) {
// If it looks like an API call by URL structure, try to get body,
// unless it's a known non-API MIME type that slipped through (e.g. a script from a /api/ path)
if (
mimeType &&
NetworkDebuggerStartTool.STATIC_MIME_TYPES_TO_FILTER.some((staticMime) =>
mimeType.startsWith(staticMime),
)
) {
return false; // e.g. a CSS file served from an /api/ path
}
return true;
}
return false;
}
private handleLoadingFailed(tabId: number, params: any) {
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) return;
const { requestId, errorText, canceled, type } = params;
const requestInfo: NetworkRequestInfo = captureInfo.requests[requestId];
if (!requestInfo) {
// console.warn(`NetworkDebuggerStartTool: LoadingFailed for unknown requestId ${requestId} on tab ${tabId}`);
return;
}
requestInfo.status = 'error';
requestInfo.errorText = errorText;
requestInfo.canceled = canceled;
if (type) requestInfo.type = type;
// timestamp here is when loading failed.
// console.log(`NetworkDebuggerStartTool: Loading failed for ${requestId} on tab ${tabId}: ${errorText}`);
}
private async getResponseBody(
tabId: number,
requestId: string,
): Promise<{ body: string; base64Encoded: boolean } | null> {
const pendingKey = `${tabId}_${requestId}`;
if (this.pendingResponseBodies.has(pendingKey)) {
return this.pendingResponseBodies.get(pendingKey)!; // Return existing promise
}
const responseBodyPromise = (async () => {
try {
// Check if debugger is still attached to this tabId
const attachedTabs = await chrome.debugger.getTargets();
if (!attachedTabs.some((target) => target.tabId === tabId && target.attached)) {
// console.warn(`NetworkDebuggerStartTool: Debugger not attached to tab ${tabId} when trying to get response body for ${requestId}.`);
throw new Error(`Debugger not attached to tab ${tabId}`);
}
const result = (await chrome.debugger.sendCommand({ tabId }, 'Network.getResponseBody', {
requestId,
})) as { body: string; base64Encoded: boolean };
return result;
} finally {
this.pendingResponseBodies.delete(pendingKey); // Clean up after promise resolves or rejects
}
})();
this.pendingResponseBodies.set(pendingKey, responseBodyPromise);
return responseBodyPromise;
}
private cleanupCapture(tabId: number) {
if (this.captureTimers.has(tabId)) {
clearTimeout(this.captureTimers.get(tabId)!);
this.captureTimers.delete(tabId);
}
if (this.inactivityTimers.has(tabId)) {
clearTimeout(this.inactivityTimers.get(tabId)!);
this.inactivityTimers.delete(tabId);
}
this.lastActivityTime.delete(tabId);
this.captureData.delete(tabId);
this.requestCounters.delete(tabId);
// Abort pending getResponseBody calls for this tab
// Note: Promises themselves cannot be "aborted" externally in a standard way once created.
// We can delete them from the map, so new calls won't use them,
// and the original promise will eventually resolve or reject.
const keysToDelete: string[] = [];
this.pendingResponseBodies.forEach((_, key) => {
if (key.startsWith(`${tabId}_`)) {
keysToDelete.push(key);
}
});
keysToDelete.forEach((key) => this.pendingResponseBodies.delete(key));
console.log(`NetworkDebuggerStartTool: Cleaned up resources for tab ${tabId}.`);
}
// isAutoStop is true if stop was triggered by timeout, false if by user/explicit call
async stopCapture(tabId: number, isAutoStop: boolean = false): Promise<any> {
const captureInfo = this.captureData.get(tabId);
if (!captureInfo) {
return { success: false, message: 'No capture in progress for this tab.' };
}
console.log(
`NetworkDebuggerStartTool: Stopping capture for tab ${tabId}. Auto-stop: ${isAutoStop}`,
);
try {
// Detach debugger first to prevent further events.
// Check if debugger is attached before trying to send commands or detach
const attachedTargets = await chrome.debugger.getTargets();
const isAttached = attachedTargets.some(
(target) => target.tabId === tabId && target.attached,
);
if (isAttached) {
try {
await chrome.debugger.sendCommand({ tabId }, 'Network.disable');
} catch (e) {
console.warn(
`NetworkDebuggerStartTool: Error disabling network for tab ${tabId} (possibly already detached):`,
e,
);
}
try {
await chrome.debugger.detach({ tabId });
} catch (e) {
console.warn(
`NetworkDebuggerStartTool: Error detaching debugger for tab ${tabId} (possibly already detached):`,
e,
);
}
} else {
console.log(
`NetworkDebuggerStartTool: Debugger was not attached to tab ${tabId} at stopCapture.`,
);
}
} catch (error: any) {
// Catch errors from getTargets or general logic
console.error(
'NetworkDebuggerStartTool: Error during debugger interaction in stopCapture:',
error,
);
// Proceed to cleanup and data formatting
}
// Process data even if detach/disable failed, as some data might have been captured.
const allRequests = Object.values(captureInfo.requests) as NetworkRequestInfo[];
const commonRequestHeaders = this.analyzeCommonHeaders(allRequests, 'requestHeaders');
const commonResponseHeaders = this.analyzeCommonHeaders(allRequests, 'responseHeaders');
const processedRequests = allRequests.map((req) => {
const finalReq: Partial<NetworkRequestInfo> &
Pick<NetworkRequestInfo, 'requestId' | 'url' | 'method' | 'type' | 'status'> = { ...req };
if (finalReq.requestHeaders) {
finalReq.specificRequestHeaders = this.filterOutCommonHeaders(
finalReq.requestHeaders,
commonRequestHeaders,
);
delete finalReq.requestHeaders; // Remove original full headers
} else {
finalReq.specificRequestHeaders = {};
}
if (finalReq.responseHeaders) {
finalReq.specificResponseHeaders = this.filterOutCommonHeaders(
finalReq.responseHeaders,
commonResponseHeaders,
);
delete finalReq.responseHeaders; // Remove original full headers
} else {
finalReq.specificResponseHeaders = {};
}
return finalReq as NetworkRequestInfo; // Cast back to full type
});
// Sort requests by requestTime
processedRequests.sort((a, b) => (a.requestTime || 0) - (b.requestTime || 0));
const resultData = {
captureStartTime: captureInfo.startTime,
captureEndTime: Date.now(),
totalDurationMs: Date.now() - captureInfo.startTime,
commonRequestHeaders,
commonResponseHeaders,
requests: processedRequests,
requestCount: processedRequests.length, // Actual stored requests
totalRequestsReceivedBeforeLimit: captureInfo.limitReached
? NetworkDebuggerStartTool.MAX_REQUESTS_PER_CAPTURE
: processedRequests.length,
requestLimitReached: !!captureInfo.limitReached,
stoppedBy: isAutoStop
? this.lastActivityTime.get(tabId)
? 'inactivity_timeout'
: 'max_capture_time'
: 'user_request',
tabUrl: captureInfo.tabUrl,
tabTitle: captureInfo.tabTitle,
};
console.log(
`NetworkDebuggerStartTool: Capture stopped for tab ${tabId}. ${resultData.requestCount} requests processed. Limit reached: ${resultData.requestLimitReached}. Stopped by: ${resultData.stoppedBy}`,
);
this.cleanupCapture(tabId); // Final cleanup of all internal states for this tab
return {
success: true,
message: `Capture stopped. ${resultData.requestCount} requests.`,
data: resultData,
};
}
private analyzeCommonHeaders(
requests: NetworkRequestInfo[],
headerTypeKey: 'requestHeaders' | 'responseHeaders',
): Record<string, string> {
if (!requests || requests.length === 0) return {};
const headerValueCounts = new Map<string, Map<string, number>>(); // headerName -> (headerValue -> count)
let requestsWithHeadersCount = 0;
for (const req of requests) {
const headers = req[headerTypeKey] as Record<string, string> | undefined;
if (headers && Object.keys(headers).length > 0) {
requestsWithHeadersCount++;
for (const name in headers) {
// Normalize header name to lowercase for consistent counting
const lowerName = name.toLowerCase();
const value = headers[name];
if (!headerValueCounts.has(lowerName)) {
headerValueCounts.set(lowerName, new Map());
}
const values = headerValueCounts.get(lowerName)!;
values.set(value, (values.get(value) || 0) + 1);
}
}
}
if (requestsWithHeadersCount === 0) return {};
const commonHeaders: Record<string, string> = {};
headerValueCounts.forEach((values, name) => {
values.forEach((count, value) => {
if (count === requestsWithHeadersCount) {
// This (name, value) pair is present in all requests that have this type of headers.
// We need to find the original casing for the header name.
// This is tricky as HTTP headers are case-insensitive. Let's pick the first encountered one.
// A more robust way would be to store original names, but lowercase comparison is standard.
// For simplicity, we'll use the lowercase name for commonHeaders keys.
// Or, find one original casing:
let originalName = name;
for (const req of requests) {
const hdrs = req[headerTypeKey] as Record<string, string> | undefined;
if (hdrs) {
const foundName = Object.keys(hdrs).find((k) => k.toLowerCase() === name);
if (foundName) {
originalName = foundName;
break;
}
}
}
commonHeaders[originalName] = value;
}
});
});
return commonHeaders;
}
private filterOutCommonHeaders(
headers: Record<string, string>,
commonHeaders: Record<string, string>,
): Record<string, string> {
if (!headers || typeof headers !== 'object') return {};
const specificHeaders: Record<string, string> = {};
const commonHeadersLower: Record<string, string> = {};
// Use Object.keys to avoid ESLint no-prototype-builtins warning
Object.keys(commonHeaders).forEach((commonName) => {
commonHeadersLower[commonName.toLowerCase()] = commonHeaders[commonName];
});
// Use Object.keys to avoid ESLint no-prototype-builtins warning
Object.keys(headers).forEach((name) => {
const lowerName = name.toLowerCase();
// If the header (by name, case-insensitively) is not in commonHeaders OR
// if its value is different from the common one, then it's specific.
if (!(lowerName in commonHeadersLower) || headers[name] !== commonHeadersLower[lowerName]) {
specificHeaders[name] = headers[name];
}
});
return specificHeaders;
}
async execute(args: NetworkDebuggerStartToolParams): Promise<ToolResult> {
const {
url: targetUrl,
maxCaptureTime = DEFAULT_MAX_CAPTURE_TIME_MS,
inactivityTimeout = DEFAULT_INACTIVITY_TIMEOUT_MS,
includeStatic = false,
} = args;
console.log(
`NetworkDebuggerStartTool: Executing with args: url=${targetUrl}, maxTime=${maxCaptureTime}, inactivityTime=${inactivityTimeout}, includeStatic=${includeStatic}`,
);
let tabToOperateOn: chrome.tabs.Tab | undefined;
try {
if (targetUrl) {
const existingTabs = await chrome.tabs.query({
url: targetUrl.startsWith('http') ? targetUrl : `*://*/*${targetUrl}*`,
}); // More specific query
if (existingTabs.length > 0 && existingTabs[0]?.id) {
tabToOperateOn = existingTabs[0];
// Ensure window gets focus and tab is truly activated
await chrome.windows.update(tabToOperateOn.windowId, { focused: true });
await chrome.tabs.update(tabToOperateOn.id!, { active: true });
} else {
tabToOperateOn = await chrome.tabs.create({ url: targetUrl, active: true });
// Wait for tab to be somewhat ready. A better way is to listen to tabs.onUpdated status='complete'
// but for debugger attachment, it just needs the tabId.
await new Promise((resolve) => setTimeout(resolve, 500)); // Short delay
}
} else {
const activeTabs = await chrome.tabs.query({ active: true, currentWindow: true });
if (activeTabs.length > 0 && activeTabs[0]?.id) {
tabToOperateOn = activeTabs[0];
} else {
return createErrorResponse('No active tab found and no URL provided.');
}
}
if (!tabToOperateOn?.id) {
return createErrorResponse('Failed to identify or create a target tab.');
}
const tabId = tabToOperateOn.id;
// Use startCaptureForTab method to start capture
try {
await this.startCaptureForTab(tabId, {
maxCaptureTime,
inactivityTimeout,
includeStatic,
});
} catch (error: any) {
return createErrorResponse(
`Failed to start capture for tab ${tabId}: ${error.message || String(error)}`,
);
}
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
message: `Network capture started on tab ${tabId}. Waiting for stop command or timeout.`,
tabId,
url: tabToOperateOn.url,
maxCaptureTime,
inactivityTimeout,
includeStatic,
maxRequests: NetworkDebuggerStartTool.MAX_REQUESTS_PER_CAPTURE,
}),
},
],
isError: false,
};
} catch (error: any) {
console.error('NetworkDebuggerStartTool: Critical error during execute:', error);
// If a tabId was involved and debugger might be attached, try to clean up.
const tabIdToClean = tabToOperateOn?.id;
if (tabIdToClean && this.captureData.has(tabIdToClean)) {
await chrome.debugger
.detach({ tabId: tabIdToClean })
.catch((e) => console.warn('Cleanup detach error:', e));
this.cleanupCapture(tabIdToClean);
}
return createErrorResponse(
`Error in NetworkDebuggerStartTool: ${error.message || String(error)}`,
);
}
}
}
/**
* Network capture stop tool - stops capture and returns results for the active tab
*/
class NetworkDebuggerStopTool extends BaseBrowserToolExecutor {
name = TOOL_NAMES.BROWSER.NETWORK_DEBUGGER_STOP;
public static instance: NetworkDebuggerStopTool | null = null;
constructor() {
super();
if (NetworkDebuggerStopTool.instance) {
return NetworkDebuggerStopTool.instance;
}
NetworkDebuggerStopTool.instance = this;
}
async execute(): Promise<ToolResult> {
console.log(`NetworkDebuggerStopTool: Executing command.`);
const startTool = NetworkDebuggerStartTool.instance;
if (!startTool) {
return createErrorResponse(
'NetworkDebuggerStartTool instance not available. Cannot stop capture.',
);
}
// Get all tabs currently capturing
const ongoingCaptures = Array.from(startTool['captureData'].keys());
console.log(
`NetworkDebuggerStopTool: Found ${ongoingCaptures.length} ongoing captures: ${ongoingCaptures.join(', ')}`,
);
if (ongoingCaptures.length === 0) {
return createErrorResponse('No active network captures found in any tab.');
}
// Get current active tab
const activeTabs = await chrome.tabs.query({ active: true, currentWindow: true });
const activeTabId = activeTabs[0]?.id;
// Determine the primary tab to stop
let primaryTabId: number;
if (activeTabId && startTool['captureData'].has(activeTabId)) {
// If current active tab is capturing, prioritize stopping it
primaryTabId = activeTabId;
console.log(
`NetworkDebuggerStopTool: Active tab ${activeTabId} is capturing, will stop it first.`,
);
} else if (ongoingCaptures.length === 1) {
// If only one tab is capturing, stop it
primaryTabId = ongoingCaptures[0];
console.log(
`NetworkDebuggerStopTool: Only one tab ${primaryTabId} is capturing, stopping it.`,
);
} else {
// If multiple tabs are capturing but current active tab is not among them, stop the first one
primaryTabId = ongoingCaptures[0];
console.log(
`NetworkDebuggerStopTool: Multiple tabs capturing, active tab not among them. Stopping tab ${primaryTabId} first.`,
);
}
// Stop capture for the primary tab
const result = await this.performStop(startTool, primaryTabId);
// If multiple tabs are capturing, stop other tabs
if (ongoingCaptures.length > 1) {
const otherTabIds = ongoingCaptures.filter((id) => id !== primaryTabId);
console.log(
`NetworkDebuggerStopTool: Stopping ${otherTabIds.length} additional captures: ${otherTabIds.join(', ')}`,
);
for (const tabId of otherTabIds) {
try {
await startTool.stopCapture(tabId);
} catch (error) {
console.error(`NetworkDebuggerStopTool: Error stopping capture on tab ${tabId}:`, error);
}
}
}
return result;
}
private async performStop(
startTool: NetworkDebuggerStartTool,
tabId: number,
): Promise<ToolResult> {
console.log(`NetworkDebuggerStopTool: Attempting to stop capture for tab ${tabId}.`);
const stopResult = await startTool.stopCapture(tabId);
if (!stopResult?.success) {
return createErrorResponse(
stopResult?.message ||
`Failed to stop network capture for tab ${tabId}. It might not have been capturing.`,
);
}
const resultData = stopResult.data || {};
// Get all tabs still capturing (there might be other tabs still capturing after stopping)
const remainingCaptures = Array.from(startTool['captureData'].keys());
// Sort requests by time
if (resultData.requests && Array.isArray(resultData.requests)) {
resultData.requests.sort(
(a: NetworkRequestInfo, b: NetworkRequestInfo) =>
(a.requestTime || 0) - (b.requestTime || 0),
);
}
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
message: `Capture for tab ${tabId} (${resultData.tabUrl || 'N/A'}) stopped. ${resultData.requestCount || 0} requests captured.`,
tabId: tabId,
tabUrl: resultData.tabUrl || 'N/A',
tabTitle: resultData.tabTitle || 'Unknown Tab',
requestCount: resultData.requestCount || 0,
commonRequestHeaders: resultData.commonRequestHeaders || {},
commonResponseHeaders: resultData.commonResponseHeaders || {},
requests: resultData.requests || [],
captureStartTime: resultData.captureStartTime,
captureEndTime: resultData.captureEndTime,
totalDurationMs: resultData.totalDurationMs,
settingsUsed: resultData.settingsUsed || {},
remainingCaptures: remainingCaptures,
totalRequestsReceived: resultData.totalRequestsReceived || resultData.requestCount || 0,
requestLimitReached: resultData.requestLimitReached || false,
}),
},
],
isError: false,
};
}
}
export const networkDebuggerStartTool = new NetworkDebuggerStartTool();
export const networkDebuggerStopTool = new NetworkDebuggerStopTool();
```
--------------------------------------------------------------------------------
/app/chrome-extension/workers/ort-wasm-simd-threaded.jsep.mjs:
--------------------------------------------------------------------------------
```
var ortWasmThreaded = (() => {
var _scriptName = import.meta.url;
return (
async function(moduleArg = {}) {
var moduleRtn;
var e=moduleArg,aa,ca,da=new Promise((a,b)=>{aa=a;ca=b}),ea="object"==typeof window,k="undefined"!=typeof WorkerGlobalScope,n="object"==typeof process&&"object"==typeof process.versions&&"string"==typeof process.versions.node&&"renderer"!=process.type,q=k&&self.name?.startsWith("em-pthread");if(n){const {createRequire:a}=await import("module");var require=a(import.meta.url),fa=require("worker_threads");global.Worker=fa.Worker;q=(k=!fa.pc)&&"em-pthread"==fa.workerData}
e.mountExternalData=(a,b)=>{a.startsWith("./")&&(a=a.substring(2));(e.Fb||(e.Fb=new Map)).set(a,b)};e.unmountExternalData=()=>{delete e.Fb};var SharedArrayBuffer=globalThis.SharedArrayBuffer??(new WebAssembly.Memory({initial:0,maximum:0,qc:!0})).buffer.constructor;
const ha=a=>async(...b)=>{try{if(e.Gb)throw Error("Session already started");const c=e.Gb={ec:b[0],errors:[]},d=await a(...b);if(e.Gb!==c)throw Error("Session mismatch");e.Kb?.flush();const f=c.errors;if(0<f.length){let g=await Promise.all(f);g=g.filter(h=>h);if(0<g.length)throw Error(g.join("\n"));}return d}finally{e.Gb=null}};
e.jsepInit=(a,b)=>{if("webgpu"===a){[e.Kb,e.Vb,e.Zb,e.Lb,e.Yb,e.kb,e.$b,e.bc,e.Wb,e.Xb,e.ac]=b;const c=e.Kb;e.jsepRegisterBuffer=(d,f,g,h)=>c.registerBuffer(d,f,g,h);e.jsepGetBuffer=d=>c.getBuffer(d);e.jsepCreateDownloader=(d,f,g)=>c.createDownloader(d,f,g);e.jsepOnCreateSession=d=>{c.onCreateSession(d)};e.jsepOnReleaseSession=d=>{c.onReleaseSession(d)};e.jsepOnRunStart=d=>c.onRunStart(d);e.cc=(d,f)=>{c.upload(d,f)}}else if("webnn"===a){const c=b[0];[e.oc,e.Ob,e.webnnEnsureTensor,e.Pb,e.webnnDownloadTensor]=
b.slice(1);e.webnnReleaseTensorId=e.Ob;e.webnnUploadTensor=e.Pb;e.webnnOnRunStart=d=>c.onRunStart(d);e.webnnOnRunEnd=c.onRunEnd.bind(c);e.webnnRegisterMLContext=(d,f)=>{c.registerMLContext(d,f)};e.webnnOnReleaseSession=d=>{c.onReleaseSession(d)};e.webnnCreateMLTensorDownloader=(d,f)=>c.createMLTensorDownloader(d,f);e.webnnRegisterMLTensor=(d,f,g,h)=>c.registerMLTensor(d,f,g,h);e.webnnCreateMLContext=d=>c.createMLContext(d);e.webnnRegisterMLConstant=(d,f,g,h,l,m)=>c.registerMLConstant(d,f,g,h,l,e.Fb,
m);e.webnnRegisterGraphInput=c.registerGraphInput.bind(c);e.webnnIsGraphInput=c.isGraphInput.bind(c);e.webnnRegisterGraphOutput=c.registerGraphOutput.bind(c);e.webnnIsGraphOutput=c.isGraphOutput.bind(c);e.webnnCreateTemporaryTensor=c.createTemporaryTensor.bind(c);e.webnnIsGraphInputOutputTypeSupported=c.isGraphInputOutputTypeSupported.bind(c)}};
let ja=()=>{const a=(b,c,d)=>(...f)=>{const g=t,h=c?.();f=b(...f);const l=c?.();h!==l&&(b=l,d(h),c=d=null);return t!=g?ia():f};(b=>{for(const c of b)e[c]=a(e[c],()=>e[c],d=>e[c]=d)})(["_OrtAppendExecutionProvider","_OrtCreateSession","_OrtRun","_OrtRunWithBinding","_OrtBindInput"]);"undefined"!==typeof ha&&(e._OrtRun=ha(e._OrtRun),e._OrtRunWithBinding=ha(e._OrtRunWithBinding));ja=void 0};e.asyncInit=()=>{ja?.()};var ka=Object.assign({},e),la="./this.program",ma=(a,b)=>{throw b;},v="",na,oa;
if(n){var fs=require("fs"),pa=require("path");import.meta.url.startsWith("data:")||(v=pa.dirname(require("url").fileURLToPath(import.meta.url))+"/");oa=a=>{a=qa(a)?new URL(a):a;return fs.readFileSync(a)};na=async a=>{a=qa(a)?new URL(a):a;return fs.readFileSync(a,void 0)};!e.thisProgram&&1<process.argv.length&&(la=process.argv[1].replace(/\\/g,"/"));process.argv.slice(2);ma=(a,b)=>{process.exitCode=a;throw b;}}else if(ea||k)k?v=self.location.href:"undefined"!=typeof document&&
document.currentScript&&(v=document.currentScript.src),_scriptName&&(v=_scriptName),v.startsWith("blob:")?v="":v=v.slice(0,v.replace(/[?#].*/,"").lastIndexOf("/")+1),n||(k&&(oa=a=>{var b=new XMLHttpRequest;b.open("GET",a,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)}),na=async a=>{if(qa(a))return new Promise((c,d)=>{var f=new XMLHttpRequest;f.open("GET",a,!0);f.responseType="arraybuffer";f.onload=()=>{200==f.status||0==f.status&&f.response?c(f.response):d(f.status)};
f.onerror=d;f.send(null)});var b=await fetch(a,{credentials:"same-origin"});if(b.ok)return b.arrayBuffer();throw Error(b.status+" : "+b.url);});var ra=console.log.bind(console),sa=console.error.bind(console);n&&(ra=(...a)=>fs.writeSync(1,a.join(" ")+"\n"),sa=(...a)=>fs.writeSync(2,a.join(" ")+"\n"));var ta=ra,x=sa;Object.assign(e,ka);ka=null;var ua=e.wasmBinary,z,va,A=!1,wa,B,xa,ya,za,Aa,Ba,Ca,C,Da,Ea,qa=a=>a.startsWith("file://");function D(){z.buffer!=B.buffer&&E();return B}
function F(){z.buffer!=B.buffer&&E();return xa}function G(){z.buffer!=B.buffer&&E();return ya}function Fa(){z.buffer!=B.buffer&&E();return za}function H(){z.buffer!=B.buffer&&E();return Aa}function I(){z.buffer!=B.buffer&&E();return Ba}function Ga(){z.buffer!=B.buffer&&E();return Ca}function J(){z.buffer!=B.buffer&&E();return Ea}
if(q){var Ha;if(n){var Ia=fa.parentPort;Ia.on("message",b=>onmessage({data:b}));Object.assign(globalThis,{self:global,postMessage:b=>Ia.postMessage(b)})}var Ja=!1;x=function(...b){b=b.join(" ");n?fs.writeSync(2,b+"\n"):console.error(b)};self.alert=function(...b){postMessage({Cb:"alert",text:b.join(" "),jc:Ka()})};self.onunhandledrejection=b=>{throw b.reason||b;};function a(b){try{var c=b.data,d=c.Cb;if("load"===d){let f=[];self.onmessage=g=>f.push(g);self.startWorker=()=>{postMessage({Cb:"loaded"});
for(let g of f)a(g);self.onmessage=a};for(const g of c.Sb)if(!e[g]||e[g].proxy)e[g]=(...h)=>{postMessage({Cb:"callHandler",Rb:g,args:h})},"print"==g&&(ta=e[g]),"printErr"==g&&(x=e[g]);z=c.lc;E();Ha(c.mc)}else if("run"===d){La(c.Bb);Ma(c.Bb,0,0,1,0,0);Na();Oa(c.Bb);Ja||(Pa(),Ja=!0);try{Qa(c.hc,c.Ib)}catch(f){if("unwind"!=f)throw f;}}else"setimmediate"!==c.target&&("checkMailbox"===d?Ja&&Ra():d&&(x(`worker: received unknown command ${d}`),x(c)))}catch(f){throw Sa(),f;}}self.onmessage=a}
function E(){var a=z.buffer;e.HEAP8=B=new Int8Array(a);e.HEAP16=ya=new Int16Array(a);e.HEAPU8=xa=new Uint8Array(a);e.HEAPU16=za=new Uint16Array(a);e.HEAP32=Aa=new Int32Array(a);e.HEAPU32=Ba=new Uint32Array(a);e.HEAPF32=Ca=new Float32Array(a);e.HEAPF64=Ea=new Float64Array(a);e.HEAP64=C=new BigInt64Array(a);e.HEAPU64=Da=new BigUint64Array(a)}q||(z=new WebAssembly.Memory({initial:256,maximum:65536,shared:!0}),E());function Ta(){q?startWorker(e):K.Da()}var Ua=0,Va=null;
function Wa(){Ua--;if(0==Ua&&Va){var a=Va;Va=null;a()}}function L(a){a="Aborted("+a+")";x(a);A=!0;a=new WebAssembly.RuntimeError(a+". Build with -sASSERTIONS for more info.");ca(a);throw a;}var Xa;async function Ya(a){if(!ua)try{var b=await na(a);return new Uint8Array(b)}catch{}if(a==Xa&&ua)a=new Uint8Array(ua);else if(oa)a=oa(a);else throw"both async and sync fetching of the wasm failed";return a}
async function Za(a,b){try{var c=await Ya(a);return await WebAssembly.instantiate(c,b)}catch(d){x(`failed to asynchronously prepare wasm: ${d}`),L(d)}}async function $a(a){var b=Xa;if(!ua&&"function"==typeof WebAssembly.instantiateStreaming&&!qa(b)&&!n)try{var c=fetch(b,{credentials:"same-origin"});return await WebAssembly.instantiateStreaming(c,a)}catch(d){x(`wasm streaming compile failed: ${d}`),x("falling back to ArrayBuffer instantiation")}return Za(b,a)}
function ab(){bb={L:cb,Aa:db,b:eb,$:fb,A:gb,pa:hb,X:ib,Z:jb,qa:kb,na:lb,ga:mb,ma:nb,J:ob,Y:pb,V:qb,oa:rb,W:sb,va:tb,E:ub,Q:vb,O:wb,D:xb,v:yb,r:zb,P:Ab,z:Bb,R:Cb,ja:Db,T:Eb,aa:Fb,M:Gb,F:Hb,ia:Oa,sa:Ib,t:Jb,Ca:Kb,w:Lb,o:Mb,m:Nb,c:Ob,Ba:Pb,n:Qb,j:Rb,u:Sb,p:Tb,f:Ub,s:Vb,l:Wb,e:Xb,k:Yb,h:Zb,g:$b,d:ac,da:bc,ea:cc,fa:dc,ba:ec,ca:fc,N:gc,xa:hc,ua:ic,i:jc,C:kc,G:lc,ta:mc,x:nc,ra:oc,U:pc,q:qc,y:rc,K:sc,S:tc,za:uc,ya:vc,ka:wc,la:xc,_:yc,B:zc,I:Ac,ha:Bc,H:Cc,a:z,wa:Dc};return{a:bb}}
var Ec={840156:(a,b,c,d,f)=>{if("undefined"==typeof e||!e.Fb)return 1;a=M(Number(a>>>0));a.startsWith("./")&&(a=a.substring(2));a=e.Fb.get(a);if(!a)return 2;b=Number(b>>>0);c=Number(c>>>0);d=Number(d>>>0);if(b+c>a.byteLength)return 3;try{const g=a.subarray(b,b+c);switch(f){case 0:F().set(g,d>>>0);break;case 1:e.nc?e.nc(d,g):e.cc(d,g);break;default:return 4}return 0}catch{return 4}},840980:(a,b,c)=>{e.Pb(a,F().subarray(b>>>0,b+c>>>0))},841044:()=>e.oc(),841086:a=>{e.Ob(a)},841123:()=>{e.Wb()},841154:()=>
{e.Xb()},841183:()=>{e.ac()},841208:a=>e.Vb(a),841241:a=>e.Zb(a),841273:(a,b,c)=>{e.Lb(Number(a),Number(b),Number(c),!0)},841336:(a,b,c)=>{e.Lb(Number(a),Number(b),Number(c))},841393:()=>"undefined"!==typeof wasmOffsetConverter,841450:a=>{e.kb("Abs",a,void 0)},841501:a=>{e.kb("Neg",a,void 0)},841552:a=>{e.kb("Floor",a,void 0)},841605:a=>{e.kb("Ceil",a,void 0)},841657:a=>{e.kb("Reciprocal",a,void 0)},841715:a=>{e.kb("Sqrt",a,void 0)},841767:a=>{e.kb("Exp",a,void 0)},841818:a=>{e.kb("Erf",a,void 0)},
841869:a=>{e.kb("Sigmoid",a,void 0)},841924:(a,b,c)=>{e.kb("HardSigmoid",a,{alpha:b,beta:c})},842003:a=>{e.kb("Log",a,void 0)},842054:a=>{e.kb("Sin",a,void 0)},842105:a=>{e.kb("Cos",a,void 0)},842156:a=>{e.kb("Tan",a,void 0)},842207:a=>{e.kb("Asin",a,void 0)},842259:a=>{e.kb("Acos",a,void 0)},842311:a=>{e.kb("Atan",a,void 0)},842363:a=>{e.kb("Sinh",a,void 0)},842415:a=>{e.kb("Cosh",a,void 0)},842467:a=>{e.kb("Asinh",a,void 0)},842520:a=>{e.kb("Acosh",a,void 0)},842573:a=>{e.kb("Atanh",a,void 0)},
842626:a=>{e.kb("Tanh",a,void 0)},842678:a=>{e.kb("Not",a,void 0)},842729:(a,b,c)=>{e.kb("Clip",a,{min:b,max:c})},842798:a=>{e.kb("Clip",a,void 0)},842850:(a,b)=>{e.kb("Elu",a,{alpha:b})},842908:a=>{e.kb("Gelu",a,void 0)},842960:a=>{e.kb("Relu",a,void 0)},843012:(a,b)=>{e.kb("LeakyRelu",a,{alpha:b})},843076:(a,b)=>{e.kb("ThresholdedRelu",a,{alpha:b})},843146:(a,b)=>{e.kb("Cast",a,{to:b})},843204:a=>{e.kb("Add",a,void 0)},843255:a=>{e.kb("Sub",a,void 0)},843306:a=>{e.kb("Mul",a,void 0)},843357:a=>
{e.kb("Div",a,void 0)},843408:a=>{e.kb("Pow",a,void 0)},843459:a=>{e.kb("Equal",a,void 0)},843512:a=>{e.kb("Greater",a,void 0)},843567:a=>{e.kb("GreaterOrEqual",a,void 0)},843629:a=>{e.kb("Less",a,void 0)},843681:a=>{e.kb("LessOrEqual",a,void 0)},843740:(a,b,c,d,f)=>{e.kb("ReduceMean",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},843915:(a,b,c,d,f)=>{e.kb("ReduceMax",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>
0,Number(f)>>>0)):[]})},844089:(a,b,c,d,f)=>{e.kb("ReduceMin",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844263:(a,b,c,d,f)=>{e.kb("ReduceProd",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844438:(a,b,c,d,f)=>{e.kb("ReduceSum",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844612:(a,b,c,d,f)=>{e.kb("ReduceL1",a,{keepDims:!!b,
noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844785:(a,b,c,d,f)=>{e.kb("ReduceL2",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844958:(a,b,c,d,f)=>{e.kb("ReduceLogSum",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},845135:(a,b,c,d,f)=>{e.kb("ReduceSumSquare",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>
0,Number(f)>>>0)):[]})},845315:(a,b,c,d,f)=>{e.kb("ReduceLogSumExp",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},845495:a=>{e.kb("Where",a,void 0)},845548:(a,b,c)=>{e.kb("Transpose",a,{perm:b?Array.from(H().subarray(Number(b)>>>0,Number(c)>>>0)):[]})},845672:(a,b,c,d)=>{e.kb("DepthToSpace",a,{blocksize:b,mode:M(c),format:d?"NHWC":"NCHW"})},845805:(a,b,c,d)=>{e.kb("DepthToSpace",a,{blocksize:b,mode:M(c),format:d?"NHWC":"NCHW"})},845938:(a,
b,c,d,f,g,h,l,m,p,r,u,w,y,ba)=>{e.kb("ConvTranspose",a,{format:m?"NHWC":"NCHW",autoPad:b,dilations:[c],group:d,kernelShape:[f],pads:[g,h],strides:[l],wIsConst:()=>!!D()[p>>>0],outputPadding:r?Array.from(H().subarray(Number(r)>>>0,Number(u)>>>0)):[],outputShape:w?Array.from(H().subarray(Number(w)>>>0,Number(y)>>>0)):[],activation:M(ba)})},846371:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("ConvTranspose",a,{format:l?"NHWC":"NCHW",autoPad:b,dilations:Array.from(H().subarray(Number(c)>>>0,(Number(c)>>>0)+2>>>
0)),group:d,kernelShape:Array.from(H().subarray(Number(f)>>>0,(Number(f)>>>0)+2>>>0)),pads:Array.from(H().subarray(Number(g)>>>0,(Number(g)>>>0)+4>>>0)),strides:Array.from(H().subarray(Number(h)>>>0,(Number(h)>>>0)+2>>>0)),wIsConst:()=>!!D()[m>>>0],outputPadding:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],outputShape:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[],activation:M(y)})},847032:(a,b,c,d,f,g,h,l,m,p,r,u,w,y,ba)=>{e.kb("ConvTranspose",a,{format:m?"NHWC":"NCHW",
autoPad:b,dilations:[c],group:d,kernelShape:[f],pads:[g,h],strides:[l],wIsConst:()=>!!D()[p>>>0],outputPadding:r?Array.from(H().subarray(Number(r)>>>0,Number(u)>>>0)):[],outputShape:w?Array.from(H().subarray(Number(w)>>>0,Number(y)>>>0)):[],activation:M(ba)})},847465:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("ConvTranspose",a,{format:l?"NHWC":"NCHW",autoPad:b,dilations:Array.from(H().subarray(Number(c)>>>0,(Number(c)>>>0)+2>>>0)),group:d,kernelShape:Array.from(H().subarray(Number(f)>>>0,(Number(f)>>>0)+
2>>>0)),pads:Array.from(H().subarray(Number(g)>>>0,(Number(g)>>>0)+4>>>0)),strides:Array.from(H().subarray(Number(h)>>>0,(Number(h)>>>0)+2>>>0)),wIsConst:()=>!!D()[m>>>0],outputPadding:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],outputShape:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[],activation:M(y)})},848126:(a,b)=>{e.kb("GlobalAveragePool",a,{format:b?"NHWC":"NCHW"})},848217:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("AveragePool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,
count_include_pad:d,storage_order:f,dilations:g?Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},848696:(a,b)=>{e.kb("GlobalAveragePool",a,{format:b?"NHWC":"NCHW"})},848787:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("AveragePool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,
storage_order:f,dilations:g?Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},849266:(a,b)=>{e.kb("GlobalMaxPool",a,{format:b?"NHWC":"NCHW"})},849353:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("MaxPool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:f,dilations:g?
Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},849828:(a,b)=>{e.kb("GlobalMaxPool",a,{format:b?"NHWC":"NCHW"})},849915:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("MaxPool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:f,dilations:g?Array.from(H().subarray(Number(g)>>>
0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},850390:(a,b,c,d,f)=>{e.kb("Gemm",a,{alpha:b,beta:c,transA:d,transB:f})},850494:a=>{e.kb("MatMul",a,void 0)},850548:(a,b,c,d)=>{e.kb("ArgMax",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},850656:(a,b,c,d)=>{e.kb("ArgMin",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},850764:(a,
b)=>{e.kb("Softmax",a,{axis:b})},850827:(a,b)=>{e.kb("Concat",a,{axis:b})},850887:(a,b,c,d,f)=>{e.kb("Split",a,{axis:b,numOutputs:c,splitSizes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},851043:a=>{e.kb("Expand",a,void 0)},851097:(a,b)=>{e.kb("Gather",a,{axis:Number(b)})},851168:(a,b)=>{e.kb("GatherElements",a,{axis:Number(b)})},851247:(a,b)=>{e.kb("GatherND",a,{batch_dims:Number(b)})},851326:(a,b,c,d,f,g,h,l,m,p,r)=>{e.kb("Resize",a,{antialias:b,axes:c?Array.from(H().subarray(Number(c)>>>
0,Number(d)>>>0)):[],coordinateTransformMode:M(f),cubicCoeffA:g,excludeOutside:h,extrapolationValue:l,keepAspectRatioPolicy:M(m),mode:M(p),nearestMode:M(r)})},851688:(a,b,c,d,f,g,h)=>{e.kb("Slice",a,{starts:b?Array.from(H().subarray(Number(b)>>>0,Number(c)>>>0)):[],ends:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[],axes:g?Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[]})},851952:a=>{e.kb("Tile",a,void 0)},852004:(a,b,c)=>{e.kb("InstanceNormalization",a,{epsilon:b,format:c?"NHWC":
"NCHW"})},852118:(a,b,c)=>{e.kb("InstanceNormalization",a,{epsilon:b,format:c?"NHWC":"NCHW"})},852232:a=>{e.kb("Range",a,void 0)},852285:(a,b)=>{e.kb("Einsum",a,{equation:M(b)})},852366:(a,b,c,d,f)=>{e.kb("Pad",a,{mode:b,value:c,pads:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},852509:(a,b,c,d,f,g)=>{e.kb("BatchNormalization",a,{epsilon:b,momentum:c,spatial:!!f,trainingMode:!!d,format:g?"NHWC":"NCHW"})},852678:(a,b,c,d,f,g)=>{e.kb("BatchNormalization",a,{epsilon:b,momentum:c,spatial:!!f,
trainingMode:!!d,format:g?"NHWC":"NCHW"})},852847:(a,b,c)=>{e.kb("CumSum",a,{exclusive:Number(b),reverse:Number(c)})},852944:(a,b,c)=>{e.kb("DequantizeLinear",a,{axis:b,blockSize:c})},853034:(a,b,c,d,f)=>{e.kb("GridSample",a,{align_corners:b,mode:M(c),padding_mode:M(d),format:f?"NHWC":"NCHW"})},853204:(a,b,c,d,f)=>{e.kb("GridSample",a,{align_corners:b,mode:M(c),padding_mode:M(d),format:f?"NHWC":"NCHW"})},853374:(a,b)=>{e.kb("ScatterND",a,{reduction:M(b)})},853459:(a,b,c,d,f,g,h,l,m)=>{e.kb("Attention",
a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:f,doRotary:g,qkvHiddenSizes:h?Array.from(H().subarray(Number(l)>>>0,Number(l)+h>>>0)):[],pastPresentShareBuffer:!!m})},853731:a=>{e.kb("BiasAdd",a,void 0)},853786:a=>{e.kb("BiasSplitGelu",a,void 0)},853847:a=>{e.kb("FastGelu",a,void 0)},853903:(a,b,c,d,f,g,h,l,m,p,r,u,w,y,ba,Wd)=>{e.kb("Conv",a,{format:u?"NHWC":"NCHW",auto_pad:b,dilations:c?Array.from(H().subarray(Number(c)>>>0,Number(d)>>>0)):[],group:f,kernel_shape:g?Array.from(H().subarray(Number(g)>>>
0,Number(h)>>>0)):[],pads:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],strides:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],w_is_const:()=>!!D()[Number(w)>>>0],activation:M(y),activation_params:ba?Array.from(Ga().subarray(Number(ba)>>>0,Number(Wd)>>>0)):[]})},854487:a=>{e.kb("Gelu",a,void 0)},854539:(a,b,c,d,f,g,h,l,m)=>{e.kb("GroupQueryAttention",a,{numHeads:b,kvNumHeads:c,scale:d,softcap:f,doRotary:g,rotaryInterleaved:h,smoothSoftmax:l,localWindowSize:m})},854756:(a,
b,c,d)=>{e.kb("LayerNormalization",a,{axis:b,epsilon:c,simplified:!!d})},854867:(a,b,c,d)=>{e.kb("LayerNormalization",a,{axis:b,epsilon:c,simplified:!!d})},854978:(a,b,c,d,f,g)=>{e.kb("MatMulNBits",a,{k:b,n:c,accuracyLevel:d,bits:f,blockSize:g})},855105:(a,b,c,d,f,g)=>{e.kb("MultiHeadAttention",a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:f,doRotary:g})},855264:(a,b)=>{e.kb("QuickGelu",a,{alpha:b})},855328:(a,b,c,d,f)=>{e.kb("RotaryEmbedding",a,{interleaved:!!b,numHeads:c,rotaryEmbeddingDim:d,
scale:f})},855467:(a,b,c)=>{e.kb("SkipLayerNormalization",a,{epsilon:b,simplified:!!c})},855569:(a,b,c)=>{e.kb("SkipLayerNormalization",a,{epsilon:b,simplified:!!c})},855671:(a,b,c,d)=>{e.kb("GatherBlockQuantized",a,{gatherAxis:b,quantizeAxis:c,blockSize:d})},855792:a=>{e.$b(a)},855826:(a,b)=>e.bc(Number(a),Number(b),e.Gb.ec,e.Gb.errors)};function db(a,b,c){return Fc(async()=>{await e.Yb(Number(a),Number(b),Number(c))})}function cb(){return"undefined"!==typeof wasmOffsetConverter}
class Gc{name="ExitStatus";constructor(a){this.message=`Program terminated with exit(${a})`;this.status=a}}
var Hc=a=>{a.terminate();a.onmessage=()=>{}},Ic=[],Mc=a=>{0==N.length&&(Jc(),Kc(N[0]));var b=N.pop();if(!b)return 6;Lc.push(b);O[a.Bb]=b;b.Bb=a.Bb;var c={Cb:"run",hc:a.fc,Ib:a.Ib,Bb:a.Bb};n&&b.unref();b.postMessage(c,a.Nb);return 0},P=0,Q=(a,b,...c)=>{for(var d=2*c.length,f=Nc(),g=Oc(8*d),h=g>>>3,l=0;l<c.length;l++){var m=c[l];"bigint"==typeof m?(C[h+2*l]=1n,C[h+2*l+1]=m):(C[h+2*l]=0n,J()[h+2*l+1>>>0]=m)}a=Pc(a,0,d,g,b);Qc(f);return a};
function Dc(a){if(q)return Q(0,1,a);wa=a;if(!(0<P)){for(var b of Lc)Hc(b);for(b of N)Hc(b);N=[];Lc=[];O={};A=!0}ma(a,new Gc(a))}function Rc(a){if(q)return Q(1,0,a);yc(a)}var yc=a=>{wa=a;if(q)throw Rc(a),"unwind";Dc(a)},N=[],Lc=[],Sc=[],O={};function Tc(){for(var a=e.numThreads-1;a--;)Jc();Ic.unshift(()=>{Ua++;Uc(()=>Wa())})}var Wc=a=>{var b=a.Bb;delete O[b];N.push(a);Lc.splice(Lc.indexOf(a),1);a.Bb=0;Vc(b)};function Na(){Sc.forEach(a=>a())}
var Kc=a=>new Promise(b=>{a.onmessage=g=>{g=g.data;var h=g.Cb;if(g.Hb&&g.Hb!=Ka()){var l=O[g.Hb];l?l.postMessage(g,g.Nb):x(`Internal error! Worker sent a message "${h}" to target pthread ${g.Hb}, but that thread no longer exists!`)}else if("checkMailbox"===h)Ra();else if("spawnThread"===h)Mc(g);else if("cleanupThread"===h)Wc(O[g.ic]);else if("loaded"===h)a.loaded=!0,n&&!a.Bb&&a.unref(),b(a);else if("alert"===h)alert(`Thread ${g.jc}: ${g.text}`);else if("setimmediate"===g.target)a.postMessage(g);else if("callHandler"===
h)e[g.Rb](...g.args);else h&&x(`worker sent an unknown command ${h}`)};a.onerror=g=>{x(`${"worker sent an error!"} ${g.filename}:${g.lineno}: ${g.message}`);throw g;};n&&(a.on("message",g=>a.onmessage({data:g})),a.on("error",g=>a.onerror(g)));var c=[],d=[],f;for(f of d)e.propertyIsEnumerable(f)&&c.push(f);a.postMessage({Cb:"load",Sb:c,lc:z,mc:va})});function Uc(a){q?a():Promise.all(N.map(Kc)).then(a)}
function Jc(){var a=new Worker(new URL(import.meta.url),{type:"module",workerData:"em-pthread",name:"em-pthread"});N.push(a)}var La=a=>{E();var b=I()[a+52>>>2>>>0];a=I()[a+56>>>2>>>0];Xc(b,b-a);Qc(b)},Qa=(a,b)=>{P=0;a=Yc(a,b);0<P?wa=a:Zc(a)};class $c{constructor(a){this.Jb=a-24}}var ad=0,bd=0;function eb(a,b,c){a>>>=0;var d=new $c(a);b>>>=0;c>>>=0;I()[d.Jb+16>>>2>>>0]=0;I()[d.Jb+4>>>2>>>0]=b;I()[d.Jb+8>>>2>>>0]=c;ad=a;bd++;throw ad;}
function cd(a,b,c,d){return q?Q(2,1,a,b,c,d):fb(a,b,c,d)}function fb(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;if("undefined"==typeof SharedArrayBuffer)return 6;var f=[];if(q&&0===f.length)return cd(a,b,c,d);a={fc:c,Bb:a,Ib:d,Nb:f};return q?(a.Cb="spawnThread",postMessage(a,f),0):Mc(a)}
var dd="undefined"!=typeof TextDecoder?new TextDecoder:void 0,ed=(a,b=0,c=NaN)=>{b>>>=0;var d=b+c;for(c=b;a[c]&&!(c>=d);)++c;if(16<c-b&&a.buffer&&dd)return dd.decode(a.buffer instanceof ArrayBuffer?a.subarray(b,c):a.slice(b,c));for(d="";b<c;){var f=a[b++];if(f&128){var g=a[b++]&63;if(192==(f&224))d+=String.fromCharCode((f&31)<<6|g);else{var h=a[b++]&63;f=224==(f&240)?(f&15)<<12|g<<6|h:(f&7)<<18|g<<12|h<<6|a[b++]&63;65536>f?d+=String.fromCharCode(f):(f-=65536,d+=String.fromCharCode(55296|f>>10,56320|
f&1023))}}else d+=String.fromCharCode(f)}return d},M=(a,b)=>(a>>>=0)?ed(F(),a,b):"";function gb(a,b,c){return q?Q(3,1,a,b,c):0}function hb(a,b){if(q)return Q(4,1,a,b)}
var fd=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=d?(b+=4,++c):b+=3}return b},gd=(a,b,c)=>{var d=F();b>>>=0;if(0<c){var f=b;c=b+c-1;for(var g=0;g<a.length;++g){var h=a.charCodeAt(g);if(55296<=h&&57343>=h){var l=a.charCodeAt(++g);h=65536+((h&1023)<<10)|l&1023}if(127>=h){if(b>=c)break;d[b++>>>0]=h}else{if(2047>=h){if(b+1>=c)break;d[b++>>>0]=192|h>>6}else{if(65535>=h){if(b+2>=c)break;d[b++>>>0]=224|h>>12}else{if(b+3>=c)break;d[b++>>>0]=240|h>>18;
d[b++>>>0]=128|h>>12&63}d[b++>>>0]=128|h>>6&63}d[b++>>>0]=128|h&63}}d[b>>>0]=0;a=b-f}else a=0;return a};function ib(a,b){if(q)return Q(5,1,a,b)}function jb(a,b,c){if(q)return Q(6,1,a,b,c)}function kb(a,b,c){return q?Q(7,1,a,b,c):0}function lb(a,b){if(q)return Q(8,1,a,b)}function mb(a,b,c){if(q)return Q(9,1,a,b,c)}function nb(a,b,c,d){if(q)return Q(10,1,a,b,c,d)}function ob(a,b,c,d){if(q)return Q(11,1,a,b,c,d)}function pb(a,b,c,d){if(q)return Q(12,1,a,b,c,d)}function qb(a){if(q)return Q(13,1,a)}
function rb(a,b){if(q)return Q(14,1,a,b)}function sb(a,b,c){if(q)return Q(15,1,a,b,c)}var tb=()=>L(""),hd,R=a=>{for(var b="";F()[a>>>0];)b+=hd[F()[a++>>>0]];return b},jd={},kd={},ld={},S;function md(a,b,c={}){var d=b.name;if(!a)throw new S(`type "${d}" must have a positive integer typeid pointer`);if(kd.hasOwnProperty(a)){if(c.Tb)return;throw new S(`Cannot register type '${d}' twice`);}kd[a]=b;delete ld[a];jd.hasOwnProperty(a)&&(b=jd[a],delete jd[a],b.forEach(f=>f()))}
function T(a,b,c={}){return md(a,b,c)}var nd=(a,b,c)=>{switch(b){case 1:return c?d=>D()[d>>>0]:d=>F()[d>>>0];case 2:return c?d=>G()[d>>>1>>>0]:d=>Fa()[d>>>1>>>0];case 4:return c?d=>H()[d>>>2>>>0]:d=>I()[d>>>2>>>0];case 8:return c?d=>C[d>>>3]:d=>Da[d>>>3];default:throw new TypeError(`invalid integer width (${b}): ${a}`);}};
function ub(a,b,c){a>>>=0;c>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:d=>d,toWireType:function(d,f){if("bigint"!=typeof f&&"number"!=typeof f)throw null===f?f="null":(d=typeof f,f="object"===d||"array"===d||"function"===d?f.toString():""+f),new TypeError(`Cannot convert "${f}" to ${this.name}`);"number"==typeof f&&(f=BigInt(f));return f},Db:U,readValueFromPointer:nd(b,c,-1==b.indexOf("u")),Eb:null})}var U=8;
function vb(a,b,c,d){a>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:function(f){return!!f},toWireType:function(f,g){return g?c:d},Db:U,readValueFromPointer:function(f){return this.fromWireType(F()[f>>>0])},Eb:null})}var od=[],V=[];function Ob(a){a>>>=0;9<a&&0===--V[a+1]&&(V[a]=void 0,od.push(a))}
var W=a=>{if(!a)throw new S("Cannot use deleted val. handle = "+a);return V[a]},X=a=>{switch(a){case void 0:return 2;case null:return 4;case !0:return 6;case !1:return 8;default:const b=od.pop()||V.length;V[b]=a;V[b+1]=1;return b}};function pd(a){return this.fromWireType(I()[a>>>2>>>0])}var qd={name:"emscripten::val",fromWireType:a=>{var b=W(a);Ob(a);return b},toWireType:(a,b)=>X(b),Db:U,readValueFromPointer:pd,Eb:null};function wb(a){return T(a>>>0,qd)}
var rd=(a,b)=>{switch(b){case 4:return function(c){return this.fromWireType(Ga()[c>>>2>>>0])};case 8:return function(c){return this.fromWireType(J()[c>>>3>>>0])};default:throw new TypeError(`invalid float width (${b}): ${a}`);}};function xb(a,b,c){a>>>=0;c>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:d=>d,toWireType:(d,f)=>f,Db:U,readValueFromPointer:rd(b,c),Eb:null})}
function yb(a,b,c,d,f){a>>>=0;c>>>=0;b=R(b>>>0);-1===f&&(f=4294967295);f=l=>l;if(0===d){var g=32-8*c;f=l=>l<<g>>>g}var h=b.includes("unsigned")?function(l,m){return m>>>0}:function(l,m){return m};T(a,{name:b,fromWireType:f,toWireType:h,Db:U,readValueFromPointer:nd(b,c,0!==d),Eb:null})}
function zb(a,b,c){function d(g){var h=I()[g>>>2>>>0];g=I()[g+4>>>2>>>0];return new f(D().buffer,g,h)}a>>>=0;var f=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,BigInt64Array,BigUint64Array][b];c=R(c>>>0);T(a,{name:c,fromWireType:d,Db:U,readValueFromPointer:d},{Tb:!0})}
function Ab(a,b){a>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:function(c){for(var d=I()[c>>>2>>>0],f=c+4,g,h=f,l=0;l<=d;++l){var m=f+l;if(l==d||0==F()[m>>>0])h=M(h,m-h),void 0===g?g=h:(g+=String.fromCharCode(0),g+=h),h=m+1}Y(c);return g},toWireType:function(c,d){d instanceof ArrayBuffer&&(d=new Uint8Array(d));var f="string"==typeof d;if(!(f||d instanceof Uint8Array||d instanceof Uint8ClampedArray||d instanceof Int8Array))throw new S("Cannot pass non-string to std::string");var g=f?fd(d):d.length;var h=
sd(4+g+1),l=h+4;I()[h>>>2>>>0]=g;if(f)gd(d,l,g+1);else if(f)for(f=0;f<g;++f){var m=d.charCodeAt(f);if(255<m)throw Y(h),new S("String has UTF-16 code units that do not fit in 8 bits");F()[l+f>>>0]=m}else for(f=0;f<g;++f)F()[l+f>>>0]=d[f];null!==c&&c.push(Y,h);return h},Db:U,readValueFromPointer:pd,Eb(c){Y(c)}})}
var td="undefined"!=typeof TextDecoder?new TextDecoder("utf-16le"):void 0,ud=(a,b)=>{var c=a>>1;for(var d=c+b/2;!(c>=d)&&Fa()[c>>>0];)++c;c<<=1;if(32<c-a&&td)return td.decode(F().slice(a,c));c="";for(d=0;!(d>=b/2);++d){var f=G()[a+2*d>>>1>>>0];if(0==f)break;c+=String.fromCharCode(f)}return c},vd=(a,b,c)=>{c??=2147483647;if(2>c)return 0;c-=2;var d=b;c=c<2*a.length?c/2:a.length;for(var f=0;f<c;++f){var g=a.charCodeAt(f);G()[b>>>1>>>0]=g;b+=2}G()[b>>>1>>>0]=0;return b-d},wd=a=>2*a.length,xd=(a,b)=>{for(var c=
0,d="";!(c>=b/4);){var f=H()[a+4*c>>>2>>>0];if(0==f)break;++c;65536<=f?(f-=65536,d+=String.fromCharCode(55296|f>>10,56320|f&1023)):d+=String.fromCharCode(f)}return d},yd=(a,b,c)=>{b>>>=0;c??=2147483647;if(4>c)return 0;var d=b;c=d+c-4;for(var f=0;f<a.length;++f){var g=a.charCodeAt(f);if(55296<=g&&57343>=g){var h=a.charCodeAt(++f);g=65536+((g&1023)<<10)|h&1023}H()[b>>>2>>>0]=g;b+=4;if(b+4>c)break}H()[b>>>2>>>0]=0;return b-d},zd=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);55296<=d&&57343>=
d&&++c;b+=4}return b};
function Bb(a,b,c){a>>>=0;b>>>=0;c>>>=0;c=R(c);if(2===b){var d=ud;var f=vd;var g=wd;var h=l=>Fa()[l>>>1>>>0]}else 4===b&&(d=xd,f=yd,g=zd,h=l=>I()[l>>>2>>>0]);T(a,{name:c,fromWireType:l=>{for(var m=I()[l>>>2>>>0],p,r=l+4,u=0;u<=m;++u){var w=l+4+u*b;if(u==m||0==h(w))r=d(r,w-r),void 0===p?p=r:(p+=String.fromCharCode(0),p+=r),r=w+b}Y(l);return p},toWireType:(l,m)=>{if("string"!=typeof m)throw new S(`Cannot pass non-string to C++ string type ${c}`);var p=g(m),r=sd(4+p+b);I()[r>>>2>>>0]=p/b;f(m,r+4,p+b);
null!==l&&l.push(Y,r);return r},Db:U,readValueFromPointer:pd,Eb(l){Y(l)}})}function Cb(a,b){a>>>=0;b=R(b>>>0);T(a,{Ub:!0,name:b,Db:0,fromWireType:()=>{},toWireType:()=>{}})}function Db(a){Ma(a>>>0,!k,1,!ea,131072,!1);Na()}var Ad=a=>{if(!A)try{if(a(),!(0<P))try{q?Zc(wa):yc(wa)}catch(b){b instanceof Gc||"unwind"==b||ma(1,b)}}catch(b){b instanceof Gc||"unwind"==b||ma(1,b)}};
function Oa(a){a>>>=0;"function"===typeof Atomics.kc&&(Atomics.kc(H(),a>>>2,a).value.then(Ra),a+=128,Atomics.store(H(),a>>>2,1))}var Ra=()=>{var a=Ka();a&&(Oa(a),Ad(Bd))};function Eb(a,b){a>>>=0;a==b>>>0?setTimeout(Ra):q?postMessage({Hb:a,Cb:"checkMailbox"}):(a=O[a])&&a.postMessage({Cb:"checkMailbox"})}var Cd=[];function Fb(a,b,c,d,f){b>>>=0;d/=2;Cd.length=d;c=f>>>0>>>3;for(f=0;f<d;f++)Cd[f]=C[c+2*f]?C[c+2*f+1]:J()[c+2*f+1>>>0];return(b?Ec[b]:Dd[a])(...Cd)}var Gb=()=>{P=0};
function Hb(a){a>>>=0;q?postMessage({Cb:"cleanupThread",ic:a}):Wc(O[a])}function Ib(a){n&&O[a>>>0].ref()}var Fd=(a,b)=>{var c=kd[a];if(void 0===c)throw a=Ed(a),c=R(a),Y(a),new S(`${b} has unknown type ${c}`);return c},Gd=(a,b,c)=>{var d=[];a=a.toWireType(d,c);d.length&&(I()[b>>>2>>>0]=X(d));return a};function Jb(a,b,c){b>>>=0;c>>>=0;a=W(a>>>0);b=Fd(b,"emval::as");return Gd(b,c,a)}function Kb(a,b){b>>>=0;a=W(a>>>0);b=Fd(b,"emval::as");return b.toWireType(null,a)}var Hd=a=>{try{a()}catch(b){L(b)}};
function Id(){var a=K,b={};for(let [c,d]of Object.entries(a))b[c]="function"==typeof d?(...f)=>{Jd.push(c);try{return d(...f)}finally{A||(Jd.pop(),t&&1===Z&&0===Jd.length&&(Z=0,P+=1,Hd(Kd),"undefined"!=typeof Fibers&&Fibers.sc()))}}:d;return b}var Z=0,t=null,Ld=0,Jd=[],Md={},Nd={},Od=0,Pd=null,Qd=[];function ia(){return new Promise((a,b)=>{Pd={resolve:a,reject:b}})}
function Rd(){var a=sd(65548),b=a+12;I()[a>>>2>>>0]=b;I()[a+4>>>2>>>0]=b+65536;b=Jd[0];var c=Md[b];void 0===c&&(c=Od++,Md[b]=c,Nd[c]=b);b=c;H()[a+8>>>2>>>0]=b;return a}function Sd(){var a=H()[t+8>>>2>>>0];a=K[Nd[a]];--P;return a()}
function Td(a){if(!A){if(0===Z){var b=!1,c=!1;a((d=0)=>{if(!A&&(Ld=d,b=!0,c)){Z=2;Hd(()=>Ud(t));"undefined"!=typeof MainLoop&&MainLoop.Qb&&MainLoop.resume();d=!1;try{var f=Sd()}catch(l){f=l,d=!0}var g=!1;if(!t){var h=Pd;h&&(Pd=null,(d?h.reject:h.resolve)(f),g=!0)}if(d&&!g)throw f;}});c=!0;b||(Z=1,t=Rd(),"undefined"!=typeof MainLoop&&MainLoop.Qb&&MainLoop.pause(),Hd(()=>Vd(t)))}else 2===Z?(Z=0,Hd(Xd),Y(t),t=null,Qd.forEach(Ad)):L(`invalid state: ${Z}`);return Ld}}
function Fc(a){return Td(b=>{a().then(b)})}function Lb(a){a>>>=0;return Fc(async()=>{var b=await W(a);return X(b)})}var Yd=[];function Mb(a,b,c,d){c>>>=0;d>>>=0;a=Yd[a>>>0];b=W(b>>>0);return a(null,b,c,d)}var Zd={},$d=a=>{var b=Zd[a];return void 0===b?R(a):b};function Nb(a,b,c,d,f){c>>>=0;d>>>=0;f>>>=0;a=Yd[a>>>0];b=W(b>>>0);c=$d(c);return a(b,b[c],d,f)}function Pb(a,b){b>>>=0;a=W(a>>>0);b=W(b);return a==b}var ae=()=>"object"==typeof globalThis?globalThis:Function("return this")();
function Qb(a){a>>>=0;if(0===a)return X(ae());a=$d(a);return X(ae()[a])}var be=a=>{var b=Yd.length;Yd.push(a);return b},ce=(a,b)=>{for(var c=Array(a),d=0;d<a;++d)c[d]=Fd(I()[b+4*d>>>2>>>0],"parameter "+d);return c},de=(a,b)=>Object.defineProperty(b,"name",{value:a});
function ee(a){var b=Function;if(!(b instanceof Function))throw new TypeError(`new_ called with constructor type ${typeof b} which is not a function`);var c=de(b.name||"unknownFunctionName",function(){});c.prototype=b.prototype;c=new c;a=b.apply(c,a);return a instanceof Object?a:c}
function Rb(a,b,c){b=ce(a,b>>>0);var d=b.shift();a--;var f="return function (obj, func, destructorsRef, args) {\n",g=0,h=[];0===c&&h.push("obj");for(var l=["retType"],m=[d],p=0;p<a;++p)h.push("arg"+p),l.push("argType"+p),m.push(b[p]),f+=` var arg${p} = argType${p}.readValueFromPointer(args${g?"+"+g:""});\n`,g+=b[p].Db;f+=` var rv = ${1===c?"new func":"func.call"}(${h.join(", ")});\n`;d.Ub||(l.push("emval_returnValue"),m.push(Gd),f+=" return emval_returnValue(retType, destructorsRef, rv);\n");l.push(f+
"};\n");a=ee(l)(...m);c=`methodCaller<(${b.map(r=>r.name).join(", ")}) => ${d.name}>`;return be(de(c,a))}function Sb(a){a=$d(a>>>0);return X(e[a])}function Tb(a,b){b>>>=0;a=W(a>>>0);b=W(b);return X(a[b])}function Ub(a){a>>>=0;9<a&&(V[a+1]+=1)}function Vb(){return X([])}function Wb(a){a=W(a>>>0);for(var b=Array(a.length),c=0;c<a.length;c++)b[c]=a[c];return X(b)}function Xb(a){return X($d(a>>>0))}function Yb(){return X({})}
function Zb(a){a>>>=0;for(var b=W(a);b.length;){var c=b.pop();b.pop()(c)}Ob(a)}function $b(a,b,c){b>>>=0;c>>>=0;a=W(a>>>0);b=W(b);c=W(c);a[b]=c}function ac(a,b){b>>>=0;a=Fd(a>>>0,"_emval_take_value");a=a.readValueFromPointer(b);return X(a)}
function bc(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);H()[b>>>2>>>0]=a.getUTCSeconds();H()[b+4>>>2>>>0]=a.getUTCMinutes();H()[b+8>>>2>>>0]=a.getUTCHours();H()[b+12>>>2>>>0]=a.getUTCDate();H()[b+16>>>2>>>0]=a.getUTCMonth();H()[b+20>>>2>>>0]=a.getUTCFullYear()-1900;H()[b+24>>>2>>>0]=a.getUTCDay();a=(a.getTime()-Date.UTC(a.getUTCFullYear(),0,1,0,0,0,0))/864E5|0;H()[b+28>>>2>>>0]=a}
var fe=a=>0===a%4&&(0!==a%100||0===a%400),ge=[0,31,60,91,121,152,182,213,244,274,305,335],he=[0,31,59,90,120,151,181,212,243,273,304,334];
function cc(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);H()[b>>>2>>>0]=a.getSeconds();H()[b+4>>>2>>>0]=a.getMinutes();H()[b+8>>>2>>>0]=a.getHours();H()[b+12>>>2>>>0]=a.getDate();H()[b+16>>>2>>>0]=a.getMonth();H()[b+20>>>2>>>0]=a.getFullYear()-1900;H()[b+24>>>2>>>0]=a.getDay();var c=(fe(a.getFullYear())?ge:he)[a.getMonth()]+a.getDate()-1|0;H()[b+28>>>2>>>0]=c;H()[b+36>>>2>>>0]=-(60*a.getTimezoneOffset());c=(new Date(a.getFullYear(),6,1)).getTimezoneOffset();
var d=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();a=(c!=d&&a.getTimezoneOffset()==Math.min(d,c))|0;H()[b+32>>>2>>>0]=a}
function dc(a){a>>>=0;var b=new Date(H()[a+20>>>2>>>0]+1900,H()[a+16>>>2>>>0],H()[a+12>>>2>>>0],H()[a+8>>>2>>>0],H()[a+4>>>2>>>0],H()[a>>>2>>>0],0),c=H()[a+32>>>2>>>0],d=b.getTimezoneOffset(),f=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),g=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),h=Math.min(g,f);0>c?H()[a+32>>>2>>>0]=Number(f!=g&&h==d):0<c!=(h==d)&&(f=Math.max(g,f),b.setTime(b.getTime()+6E4*((0<c?h:f)-d)));H()[a+24>>>2>>>0]=b.getDay();c=(fe(b.getFullYear())?ge:he)[b.getMonth()]+
b.getDate()-1|0;H()[a+28>>>2>>>0]=c;H()[a>>>2>>>0]=b.getSeconds();H()[a+4>>>2>>>0]=b.getMinutes();H()[a+8>>>2>>>0]=b.getHours();H()[a+12>>>2>>>0]=b.getDate();H()[a+16>>>2>>>0]=b.getMonth();H()[a+20>>>2>>>0]=b.getYear();a=b.getTime();return BigInt(isNaN(a)?-1:a/1E3)}function ec(a,b,c,d,f,g,h){return q?Q(16,1,a,b,c,d,f,g,h):-52}function fc(a,b,c,d,f,g){if(q)return Q(17,1,a,b,c,d,f,g)}var ie={},qc=()=>performance.timeOrigin+performance.now();
function gc(a,b){if(q)return Q(18,1,a,b);ie[a]&&(clearTimeout(ie[a].id),delete ie[a]);if(!b)return 0;var c=setTimeout(()=>{delete ie[a];Ad(()=>je(a,performance.timeOrigin+performance.now()))},b);ie[a]={id:c,rc:b};return 0}
function hc(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;var f=(new Date).getFullYear(),g=(new Date(f,0,1)).getTimezoneOffset();f=(new Date(f,6,1)).getTimezoneOffset();var h=Math.max(g,f);I()[a>>>2>>>0]=60*h;H()[b>>>2>>>0]=Number(g!=f);b=l=>{var m=Math.abs(l);return`UTC${0<=l?"-":"+"}${String(Math.floor(m/60)).padStart(2,"0")}${String(m%60).padStart(2,"0")}`};a=b(g);b=b(f);f<g?(gd(a,c,17),gd(b,d,17)):(gd(a,d,17),gd(b,c,17))}var mc=()=>Date.now(),ke=1;
function ic(a,b,c){if(!(0<=a&&3>=a))return 28;if(0===a)a=Date.now();else if(ke)a=performance.timeOrigin+performance.now();else return 52;C[c>>>0>>>3]=BigInt(Math.round(1E6*a));return 0}var le=[],me=(a,b)=>{le.length=0;for(var c;c=F()[a++>>>0];){var d=105!=c;d&=112!=c;b+=d&&b%8?4:0;le.push(112==c?I()[b>>>2>>>0]:106==c?C[b>>>3]:105==c?H()[b>>>2>>>0]:J()[b>>>3>>>0]);b+=d?8:4}return le};function jc(a,b,c){a>>>=0;b=me(b>>>0,c>>>0);return Ec[a](...b)}
function kc(a,b,c){a>>>=0;b=me(b>>>0,c>>>0);return Ec[a](...b)}var lc=()=>{};function nc(a,b){return x(M(a>>>0,b>>>0))}var oc=()=>{P+=1;throw"unwind";};function pc(){return 4294901760}var rc=()=>n?require("os").cpus().length:navigator.hardwareConcurrency;function sc(){L("Cannot use emscripten_pc_get_function without -sUSE_OFFSET_CONVERTER");return 0}
function tc(a){a>>>=0;var b=F().length;if(a<=b||4294901760<a)return!1;for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);a:{d=(Math.min(4294901760,65536*Math.ceil(Math.max(a,d)/65536))-z.buffer.byteLength+65535)/65536|0;try{z.grow(d);E();var f=1;break a}catch(g){}f=void 0}if(f)return!0}return!1}var ne=()=>{L("Cannot use convertFrameToPC (needed by __builtin_return_address) without -sUSE_OFFSET_CONVERTER");return 0},oe={},pe=a=>{a.forEach(b=>{var c=ne();c&&(oe[c]=b)})};
function uc(){var a=Error().stack.toString().split("\n");"Error"==a[0]&&a.shift();pe(a);oe.Mb=ne();oe.dc=a;return oe.Mb}function vc(a,b,c){a>>>=0;b>>>=0;if(oe.Mb==a)var d=oe.dc;else d=Error().stack.toString().split("\n"),"Error"==d[0]&&d.shift(),pe(d);for(var f=3;d[f]&&ne()!=a;)++f;for(a=0;a<c&&d[a+f];++a)H()[b+4*a>>>2>>>0]=ne();return a}
var qe={},se=()=>{if(!re){var a={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"==typeof navigator&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",_:la||"./this.program"},b;for(b in qe)void 0===qe[b]?delete a[b]:a[b]=qe[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);re=c}return re},re;
function wc(a,b){if(q)return Q(19,1,a,b);a>>>=0;b>>>=0;var c=0;se().forEach((d,f)=>{var g=b+c;f=I()[a+4*f>>>2>>>0]=g;for(g=0;g<d.length;++g)D()[f++>>>0]=d.charCodeAt(g);D()[f>>>0]=0;c+=d.length+1});return 0}function xc(a,b){if(q)return Q(20,1,a,b);a>>>=0;b>>>=0;var c=se();I()[a>>>2>>>0]=c.length;var d=0;c.forEach(f=>d+=f.length+1);I()[b>>>2>>>0]=d;return 0}function zc(a){return q?Q(21,1,a):52}function Ac(a,b,c,d){return q?Q(22,1,a,b,c,d):52}function Bc(a,b,c,d){return q?Q(23,1,a,b,c,d):70}
var te=[null,[],[]];function Cc(a,b,c,d){if(q)return Q(24,1,a,b,c,d);b>>>=0;c>>>=0;d>>>=0;for(var f=0,g=0;g<c;g++){var h=I()[b>>>2>>>0],l=I()[b+4>>>2>>>0];b+=8;for(var m=0;m<l;m++){var p=F()[h+m>>>0],r=te[a];0===p||10===p?((1===a?ta:x)(ed(r)),r.length=0):r.push(p)}f+=l}I()[d>>>2>>>0]=f;return 0}q||Tc();for(var ue=Array(256),ve=0;256>ve;++ve)ue[ve]=String.fromCharCode(ve);hd=ue;S=e.BindingError=class extends Error{constructor(a){super(a);this.name="BindingError"}};
e.InternalError=class extends Error{constructor(a){super(a);this.name="InternalError"}};V.push(0,1,void 0,1,null,1,!0,1,!1,1);e.count_emval_handles=()=>V.length/2-5-od.length;var Dd=[Dc,Rc,cd,gb,hb,ib,jb,kb,lb,mb,nb,ob,pb,qb,rb,sb,ec,fc,gc,wc,xc,zc,Ac,Bc,Cc],bb,K;
(async function(){function a(d,f){K=d.exports;K=Id();K=we();Sc.push(K.jb);va=f;Wa();return K}Ua++;var b=ab();if(e.instantiateWasm)return new Promise(d=>{e.instantiateWasm(b,(f,g)=>{a(f,g);d(f.exports)})});if(q)return new Promise(d=>{Ha=f=>{var g=new WebAssembly.Instance(f,ab());d(a(g,f))}});Xa??=e.locateFile?e.locateFile?e.locateFile("ort-wasm-simd-threaded.jsep.wasm",v):v+"ort-wasm-simd-threaded.jsep.wasm":(new URL("ort-wasm-simd-threaded.jsep.wasm",import.meta.url)).href;try{var c=await $a(b);
return a(c.instance,c.module)}catch(d){return ca(d),Promise.reject(d)}})();var Ed=a=>(Ed=K.Ea)(a),Pa=()=>(Pa=K.Fa)();e._OrtInit=(a,b)=>(e._OrtInit=K.Ga)(a,b);e._OrtGetLastError=(a,b)=>(e._OrtGetLastError=K.Ha)(a,b);e._OrtCreateSessionOptions=(a,b,c,d,f,g,h,l,m,p)=>(e._OrtCreateSessionOptions=K.Ia)(a,b,c,d,f,g,h,l,m,p);e._OrtAppendExecutionProvider=(a,b,c,d,f)=>(e._OrtAppendExecutionProvider=K.Ja)(a,b,c,d,f);e._OrtAddFreeDimensionOverride=(a,b,c)=>(e._OrtAddFreeDimensionOverride=K.Ka)(a,b,c);
e._OrtAddSessionConfigEntry=(a,b,c)=>(e._OrtAddSessionConfigEntry=K.La)(a,b,c);e._OrtReleaseSessionOptions=a=>(e._OrtReleaseSessionOptions=K.Ma)(a);e._OrtCreateSession=(a,b,c)=>(e._OrtCreateSession=K.Na)(a,b,c);e._OrtReleaseSession=a=>(e._OrtReleaseSession=K.Oa)(a);e._OrtGetInputOutputCount=(a,b,c)=>(e._OrtGetInputOutputCount=K.Pa)(a,b,c);e._OrtGetInputOutputMetadata=(a,b,c,d)=>(e._OrtGetInputOutputMetadata=K.Qa)(a,b,c,d);e._OrtFree=a=>(e._OrtFree=K.Ra)(a);
e._OrtCreateTensor=(a,b,c,d,f,g)=>(e._OrtCreateTensor=K.Sa)(a,b,c,d,f,g);e._OrtGetTensorData=(a,b,c,d,f)=>(e._OrtGetTensorData=K.Ta)(a,b,c,d,f);e._OrtReleaseTensor=a=>(e._OrtReleaseTensor=K.Ua)(a);e._OrtCreateRunOptions=(a,b,c,d)=>(e._OrtCreateRunOptions=K.Va)(a,b,c,d);e._OrtAddRunConfigEntry=(a,b,c)=>(e._OrtAddRunConfigEntry=K.Wa)(a,b,c);e._OrtReleaseRunOptions=a=>(e._OrtReleaseRunOptions=K.Xa)(a);e._OrtCreateBinding=a=>(e._OrtCreateBinding=K.Ya)(a);
e._OrtBindInput=(a,b,c)=>(e._OrtBindInput=K.Za)(a,b,c);e._OrtBindOutput=(a,b,c,d)=>(e._OrtBindOutput=K._a)(a,b,c,d);e._OrtClearBoundOutputs=a=>(e._OrtClearBoundOutputs=K.$a)(a);e._OrtReleaseBinding=a=>(e._OrtReleaseBinding=K.ab)(a);e._OrtRunWithBinding=(a,b,c,d,f)=>(e._OrtRunWithBinding=K.bb)(a,b,c,d,f);e._OrtRun=(a,b,c,d,f,g,h,l)=>(e._OrtRun=K.cb)(a,b,c,d,f,g,h,l);e._OrtEndProfiling=a=>(e._OrtEndProfiling=K.db)(a);e._JsepOutput=(a,b,c)=>(e._JsepOutput=K.eb)(a,b,c);
e._JsepGetNodeName=a=>(e._JsepGetNodeName=K.fb)(a);
var Ka=()=>(Ka=K.gb)(),Y=e._free=a=>(Y=e._free=K.hb)(a),sd=e._malloc=a=>(sd=e._malloc=K.ib)(a),Ma=(a,b,c,d,f,g)=>(Ma=K.lb)(a,b,c,d,f,g),Sa=()=>(Sa=K.mb)(),Pc=(a,b,c,d,f)=>(Pc=K.nb)(a,b,c,d,f),Vc=a=>(Vc=K.ob)(a),Zc=a=>(Zc=K.pb)(a),je=(a,b)=>(je=K.qb)(a,b),Bd=()=>(Bd=K.rb)(),Xc=(a,b)=>(Xc=K.sb)(a,b),Qc=a=>(Qc=K.tb)(a),Oc=a=>(Oc=K.ub)(a),Nc=()=>(Nc=K.vb)(),Yc=e.dynCall_ii=(a,b)=>(Yc=e.dynCall_ii=K.wb)(a,b),Vd=a=>(Vd=K.xb)(a),Kd=()=>(Kd=K.yb)(),Ud=a=>(Ud=K.zb)(a),Xd=()=>(Xd=K.Ab)();
function we(){var a=K;a=Object.assign({},a);var b=d=>f=>d(f)>>>0,c=d=>()=>d()>>>0;a.Ea=b(a.Ea);a.gb=c(a.gb);a.ib=b(a.ib);a.ub=b(a.ub);a.vb=c(a.vb);a.__cxa_get_exception_ptr=b(a.__cxa_get_exception_ptr);return a}e.stackSave=()=>Nc();e.stackRestore=a=>Qc(a);e.stackAlloc=a=>Oc(a);
e.setValue=function(a,b,c="i8"){c.endsWith("*")&&(c="*");switch(c){case "i1":D()[a>>>0]=b;break;case "i8":D()[a>>>0]=b;break;case "i16":G()[a>>>1>>>0]=b;break;case "i32":H()[a>>>2>>>0]=b;break;case "i64":C[a>>>3]=BigInt(b);break;case "float":Ga()[a>>>2>>>0]=b;break;case "double":J()[a>>>3>>>0]=b;break;case "*":I()[a>>>2>>>0]=b;break;default:L(`invalid type for setValue: ${c}`)}};
e.getValue=function(a,b="i8"){b.endsWith("*")&&(b="*");switch(b){case "i1":return D()[a>>>0];case "i8":return D()[a>>>0];case "i16":return G()[a>>>1>>>0];case "i32":return H()[a>>>2>>>0];case "i64":return C[a>>>3];case "float":return Ga()[a>>>2>>>0];case "double":return J()[a>>>3>>>0];case "*":return I()[a>>>2>>>0];default:L(`invalid type for getValue: ${b}`)}};e.UTF8ToString=M;e.stringToUTF8=gd;e.lengthBytesUTF8=fd;
function xe(){if(0<Ua)Va=xe;else if(q)aa(e),Ta();else{for(;0<Ic.length;)Ic.shift()(e);0<Ua?Va=xe:(e.calledRun=!0,A||(Ta(),aa(e)))}}xe();e.PTR_SIZE=4;moduleRtn=da;
return moduleRtn;
}
);
})();
export default ortWasmThreaded;
var isPthread = globalThis.self?.name?.startsWith('em-pthread');
var isNode = typeof globalThis.process?.versions?.node == 'string';
if (isNode) isPthread = (await import('worker_threads')).workerData === 'em-pthread';
// When running as a pthread, construct a new instance on startup
isPthread && ortWasmThreaded();
```
--------------------------------------------------------------------------------
/app/chrome-extension/entrypoints/popup/App.vue:
--------------------------------------------------------------------------------
```vue
<template>
<div class="popup-container">
<div class="header">
<div class="header-content">
<h1 class="header-title">Chrome MCP Server</h1>
</div>
</div>
<div class="content">
<div class="section">
<h2 class="section-title">{{ getMessage('nativeServerConfigLabel') }}</h2>
<div class="config-card">
<div class="status-section">
<div class="status-header">
<p class="status-label">{{ getMessage('runningStatusLabel') }}</p>
<button
class="refresh-status-button"
@click="refreshServerStatus"
:title="getMessage('refreshStatusButton')"
>
🔄
</button>
</div>
<div class="status-info">
<span :class="['status-dot', getStatusClass()]"></span>
<span class="status-text">{{ getStatusText() }}</span>
</div>
<div v-if="serverStatus.lastUpdated" class="status-timestamp">
{{ getMessage('lastUpdatedLabel') }}
{{ new Date(serverStatus.lastUpdated).toLocaleTimeString() }}
</div>
</div>
<div v-if="showMcpConfig" class="mcp-config-section">
<div class="mcp-config-header">
<p class="mcp-config-label">{{ getMessage('mcpServerConfigLabel') }}</p>
<button class="copy-config-button" @click="copyMcpConfig">
{{ copyButtonText }}
</button>
</div>
<div class="mcp-config-content">
<pre class="mcp-config-json">{{ mcpConfigJson }}</pre>
</div>
</div>
<div class="port-section">
<label for="port" class="port-label">{{ getMessage('connectionPortLabel') }}</label>
<input
type="text"
id="port"
:value="nativeServerPort"
@input="updatePort"
class="port-input"
/>
</div>
<button class="connect-button" :disabled="isConnecting" @click="testNativeConnection">
<BoltIcon />
<span>{{
isConnecting
? getMessage('connectingStatus')
: nativeConnectionStatus === 'connected'
? getMessage('disconnectButton')
: getMessage('connectButton')
}}</span>
</button>
</div>
</div>
<div class="section">
<h2 class="section-title">{{ getMessage('semanticEngineLabel') }}</h2>
<div class="semantic-engine-card">
<div class="semantic-engine-status">
<div class="status-info">
<span :class="['status-dot', getSemanticEngineStatusClass()]"></span>
<span class="status-text">{{ getSemanticEngineStatusText() }}</span>
</div>
<div v-if="semanticEngineLastUpdated" class="status-timestamp">
{{ getMessage('lastUpdatedLabel') }}
{{ new Date(semanticEngineLastUpdated).toLocaleTimeString() }}
</div>
</div>
<ProgressIndicator
v-if="isSemanticEngineInitializing"
:visible="isSemanticEngineInitializing"
:text="semanticEngineInitProgress"
:showSpinner="true"
/>
<button
class="semantic-engine-button"
:disabled="isSemanticEngineInitializing"
@click="initializeSemanticEngine"
>
<BoltIcon />
<span>{{ getSemanticEngineButtonText() }}</span>
</button>
</div>
</div>
<div class="section">
<h2 class="section-title">{{ getMessage('embeddingModelLabel') }}</h2>
<ProgressIndicator
v-if="isModelSwitching || isModelDownloading"
:visible="isModelSwitching || isModelDownloading"
:text="getProgressText()"
:showSpinner="true"
/>
<div v-if="modelInitializationStatus === 'error'" class="error-card">
<div class="error-content">
<div class="error-icon">⚠️</div>
<div class="error-details">
<p class="error-title">{{ getMessage('semanticEngineInitFailedStatus') }}</p>
<p class="error-message">{{
modelErrorMessage || getMessage('semanticEngineInitFailedStatus')
}}</p>
<p class="error-suggestion">{{ getErrorTypeText() }}</p>
</div>
</div>
<button
class="retry-button"
@click="retryModelInitialization"
:disabled="isModelSwitching || isModelDownloading"
>
<span>🔄</span>
<span>{{ getMessage('retryButton') }}</span>
</button>
</div>
<div class="model-list">
<div
v-for="model in availableModels"
:key="model.preset"
:class="[
'model-card',
{
selected: currentModel === model.preset,
disabled: isModelSwitching || isModelDownloading,
},
]"
@click="
!isModelSwitching && !isModelDownloading && switchModel(model.preset as ModelPreset)
"
>
<div class="model-header">
<div class="model-info">
<p class="model-name" :class="{ 'selected-text': currentModel === model.preset }">
{{ model.preset }}
</p>
<p class="model-description">{{ getModelDescription(model) }}</p>
</div>
<div v-if="currentModel === model.preset" class="check-icon">
<CheckIcon class="text-white" />
</div>
</div>
<div class="model-tags">
<span class="model-tag performance">{{ getPerformanceText(model.performance) }}</span>
<span class="model-tag size">{{ model.size }}</span>
<span class="model-tag dimension">{{ model.dimension }}D</span>
</div>
</div>
</div>
</div>
<div class="section">
<h2 class="section-title">{{ getMessage('indexDataManagementLabel') }}</h2>
<div class="stats-grid">
<div class="stats-card">
<div class="stats-header">
<p class="stats-label">{{ getMessage('indexedPagesLabel') }}</p>
<span class="stats-icon violet">
<DocumentIcon />
</span>
</div>
<p class="stats-value">{{ storageStats?.indexedPages || 0 }}</p>
</div>
<div class="stats-card">
<div class="stats-header">
<p class="stats-label">{{ getMessage('indexSizeLabel') }}</p>
<span class="stats-icon teal">
<DatabaseIcon />
</span>
</div>
<p class="stats-value">{{ formatIndexSize() }}</p>
</div>
<div class="stats-card">
<div class="stats-header">
<p class="stats-label">{{ getMessage('activeTabsLabel') }}</p>
<span class="stats-icon blue">
<TabIcon />
</span>
</div>
<p class="stats-value">{{ getActiveTabsCount() }}</p>
</div>
<div class="stats-card">
<div class="stats-header">
<p class="stats-label">{{ getMessage('vectorDocumentsLabel') }}</p>
<span class="stats-icon green">
<VectorIcon />
</span>
</div>
<p class="stats-value">{{ storageStats?.totalDocuments || 0 }}</p>
</div>
</div>
<ProgressIndicator
v-if="isClearingData && clearDataProgress"
:visible="isClearingData"
:text="clearDataProgress"
:showSpinner="true"
/>
<button
class="danger-button"
:disabled="isClearingData"
@click="showClearConfirmation = true"
>
<TrashIcon />
<span>{{ isClearingData ? getMessage('clearingStatus') : getMessage('clearAllDataButton') }}</span>
</button>
</div>
<!-- Model Cache Management Section -->
<ModelCacheManagement
:cache-stats="cacheStats"
:is-managing-cache="isManagingCache"
@cleanup-cache="cleanupCache"
@clear-all-cache="clearAllCache"
/>
</div>
<div class="footer">
<p class="footer-text">chrome mcp server for ai</p>
</div>
<ConfirmDialog
:visible="showClearConfirmation"
:title="getMessage('confirmClearDataTitle')"
:message="getMessage('clearDataWarningMessage')"
:items="[
getMessage('clearDataList1'),
getMessage('clearDataList2'),
getMessage('clearDataList3'),
]"
:warning="getMessage('clearDataIrreversibleWarning')"
icon="⚠️"
:confirm-text="getMessage('confirmClearButton')"
:cancel-text="getMessage('cancelButton')"
:confirming-text="getMessage('clearingStatus')"
:is-confirming="isClearingData"
@confirm="confirmClearAllData"
@cancel="hideClearDataConfirmation"
/>
</div>
</template>
<script lang="ts" setup>
import { ref, onMounted, onUnmounted, computed } from 'vue';
import {
PREDEFINED_MODELS,
type ModelPreset,
getModelInfo,
getCacheStats,
clearModelCache,
cleanupModelCache,
} from '@/utils/semantic-similarity-engine';
import { BACKGROUND_MESSAGE_TYPES } from '@/common/message-types';
import { getMessage } from '@/utils/i18n';
import ConfirmDialog from './components/ConfirmDialog.vue';
import ProgressIndicator from './components/ProgressIndicator.vue';
import ModelCacheManagement from './components/ModelCacheManagement.vue';
import {
DocumentIcon,
DatabaseIcon,
BoltIcon,
TrashIcon,
CheckIcon,
TabIcon,
VectorIcon,
} from './components/icons';
const nativeConnectionStatus = ref<'unknown' | 'connected' | 'disconnected'>('unknown');
const isConnecting = ref(false);
const nativeServerPort = ref<number>(12306);
const serverStatus = ref<{
isRunning: boolean;
port?: number;
lastUpdated: number;
}>({
isRunning: false,
lastUpdated: Date.now(),
});
const showMcpConfig = computed(() => {
return nativeConnectionStatus.value === 'connected' && serverStatus.value.isRunning;
});
const copyButtonText = ref(getMessage('copyConfigButton'));
const mcpConfigJson = computed(() => {
const port = serverStatus.value.port || nativeServerPort.value;
const config = {
mcpServers: {
'streamable-mcp-server': {
type: 'streamable-http',
url: `http://127.0.0.1:${port}/mcp`,
},
},
};
return JSON.stringify(config, null, 2);
});
const currentModel = ref<ModelPreset | null>(null);
const isModelSwitching = ref(false);
const modelSwitchProgress = ref('');
const modelDownloadProgress = ref<number>(0);
const isModelDownloading = ref(false);
const modelInitializationStatus = ref<'idle' | 'downloading' | 'initializing' | 'ready' | 'error'>(
'idle',
);
const modelErrorMessage = ref<string>('');
const modelErrorType = ref<'network' | 'file' | 'unknown' | ''>('');
const selectedVersion = ref<'quantized'>('quantized');
const storageStats = ref<{
indexedPages: number;
totalDocuments: number;
totalTabs: number;
indexSize: number;
isInitialized: boolean;
} | null>(null);
const isRefreshingStats = ref(false);
const isClearingData = ref(false);
const showClearConfirmation = ref(false);
const clearDataProgress = ref('');
const semanticEngineStatus = ref<'idle' | 'initializing' | 'ready' | 'error'>('idle');
const isSemanticEngineInitializing = ref(false);
const semanticEngineInitProgress = ref('');
const semanticEngineLastUpdated = ref<number | null>(null);
// Cache management
const isManagingCache = ref(false);
const cacheStats = ref<{
totalSize: number;
totalSizeMB: number;
entryCount: number;
entries: Array<{
url: string;
size: number;
sizeMB: number;
timestamp: number;
age: string;
expired: boolean;
}>;
} | null>(null);
const availableModels = computed(() => {
return Object.entries(PREDEFINED_MODELS).map(([key, value]) => ({
preset: key as ModelPreset,
...value,
}));
});
const getStatusClass = () => {
if (nativeConnectionStatus.value === 'connected') {
if (serverStatus.value.isRunning) {
return 'bg-emerald-500';
} else {
return 'bg-yellow-500';
}
} else if (nativeConnectionStatus.value === 'disconnected') {
return 'bg-red-500';
} else {
return 'bg-gray-500';
}
};
const getStatusText = () => {
if (nativeConnectionStatus.value === 'connected') {
if (serverStatus.value.isRunning) {
return getMessage('serviceRunningStatus', [(serverStatus.value.port || 'Unknown').toString()]);
} else {
return getMessage('connectedServiceNotStartedStatus');
}
} else if (nativeConnectionStatus.value === 'disconnected') {
return getMessage('serviceNotConnectedStatus');
} else {
return getMessage('detectingStatus');
}
};
const formatIndexSize = () => {
if (!storageStats.value?.indexSize) return '0 MB';
const sizeInMB = Math.round(storageStats.value.indexSize / (1024 * 1024));
return `${sizeInMB} MB`;
};
const getModelDescription = (model: any) => {
switch (model.preset) {
case 'multilingual-e5-small':
return getMessage('lightweightModelDescription');
case 'multilingual-e5-base':
return getMessage('betterThanSmallDescription');
default:
return getMessage('multilingualModelDescription');
}
};
const getPerformanceText = (performance: string) => {
switch (performance) {
case 'fast':
return getMessage('fastPerformance');
case 'balanced':
return getMessage('balancedPerformance');
case 'accurate':
return getMessage('accuratePerformance');
default:
return performance;
}
};
const getSemanticEngineStatusText = () => {
switch (semanticEngineStatus.value) {
case 'ready':
return getMessage('semanticEngineReadyStatus');
case 'initializing':
return getMessage('semanticEngineInitializingStatus');
case 'error':
return getMessage('semanticEngineInitFailedStatus');
case 'idle':
default:
return getMessage('semanticEngineNotInitStatus');
}
};
const getSemanticEngineStatusClass = () => {
switch (semanticEngineStatus.value) {
case 'ready':
return 'bg-emerald-500';
case 'initializing':
return 'bg-yellow-500';
case 'error':
return 'bg-red-500';
case 'idle':
default:
return 'bg-gray-500';
}
};
const getActiveTabsCount = () => {
return storageStats.value?.totalTabs || 0;
};
const getProgressText = () => {
if (isModelDownloading.value) {
return getMessage('downloadingModelStatus', [modelDownloadProgress.value.toString()]);
} else if (isModelSwitching.value) {
return modelSwitchProgress.value || getMessage('switchingModelStatus');
}
return '';
};
const getErrorTypeText = () => {
switch (modelErrorType.value) {
case 'network':
return getMessage('networkErrorMessage');
case 'file':
return getMessage('modelCorruptedErrorMessage');
case 'unknown':
default:
return getMessage('unknownErrorMessage');
}
};
const getSemanticEngineButtonText = () => {
switch (semanticEngineStatus.value) {
case 'ready':
return getMessage('reinitializeButton');
case 'initializing':
return getMessage('initializingStatus');
case 'error':
return getMessage('reinitializeButton');
case 'idle':
default:
return getMessage('initSemanticEngineButton');
}
};
const loadCacheStats = async () => {
try {
cacheStats.value = await getCacheStats();
} catch (error) {
console.error('Failed to get cache stats:', error);
cacheStats.value = null;
}
};
const cleanupCache = async () => {
if (isManagingCache.value) return;
isManagingCache.value = true;
try {
await cleanupModelCache();
// Refresh cache stats
await loadCacheStats();
} catch (error) {
console.error('Failed to cleanup cache:', error);
} finally {
isManagingCache.value = false;
}
};
const clearAllCache = async () => {
if (isManagingCache.value) return;
isManagingCache.value = true;
try {
await clearModelCache();
// Refresh cache stats
await loadCacheStats();
} catch (error) {
console.error('Failed to clear cache:', error);
} finally {
isManagingCache.value = false;
}
};
const saveSemanticEngineState = async () => {
try {
const semanticEngineState = {
status: semanticEngineStatus.value,
lastUpdated: semanticEngineLastUpdated.value,
};
// eslint-disable-next-line no-undef
await chrome.storage.local.set({ semanticEngineState });
} catch (error) {
console.error('保存语义引擎状态失败:', error);
}
};
const initializeSemanticEngine = async () => {
if (isSemanticEngineInitializing.value) return;
const isReinitialization = semanticEngineStatus.value === 'ready';
console.log(
`🚀 User triggered semantic engine ${isReinitialization ? 'reinitialization' : 'initialization'}`,
);
isSemanticEngineInitializing.value = true;
semanticEngineStatus.value = 'initializing';
semanticEngineInitProgress.value = isReinitialization
? getMessage('semanticEngineInitializingStatus')
: getMessage('semanticEngineInitializingStatus');
semanticEngineLastUpdated.value = Date.now();
await saveSemanticEngineState();
try {
// eslint-disable-next-line no-undef
chrome.runtime
.sendMessage({
type: BACKGROUND_MESSAGE_TYPES.INITIALIZE_SEMANTIC_ENGINE,
})
.catch((error) => {
console.error('❌ Error sending semantic engine initialization request:', error);
});
startSemanticEngineStatusPolling();
semanticEngineInitProgress.value = isReinitialization
? getMessage('processingStatus')
: getMessage('processingStatus');
} catch (error: any) {
console.error('❌ Failed to send initialization request:', error);
semanticEngineStatus.value = 'error';
semanticEngineInitProgress.value = `Failed to send initialization request: ${error?.message || 'Unknown error'}`;
await saveSemanticEngineState();
setTimeout(() => {
semanticEngineInitProgress.value = '';
}, 5000);
isSemanticEngineInitializing.value = false;
semanticEngineLastUpdated.value = Date.now();
await saveSemanticEngineState();
}
};
const checkSemanticEngineStatus = async () => {
try {
// eslint-disable-next-line no-undef
const response = await chrome.runtime.sendMessage({
type: BACKGROUND_MESSAGE_TYPES.GET_MODEL_STATUS,
});
if (response && response.success && response.status) {
const status = response.status;
if (status.initializationStatus === 'ready') {
semanticEngineStatus.value = 'ready';
semanticEngineLastUpdated.value = Date.now();
isSemanticEngineInitializing.value = false;
semanticEngineInitProgress.value = getMessage('semanticEngineReadyStatus');
await saveSemanticEngineState();
stopSemanticEngineStatusPolling();
setTimeout(() => {
semanticEngineInitProgress.value = '';
}, 2000);
} else if (
status.initializationStatus === 'downloading' ||
status.initializationStatus === 'initializing'
) {
semanticEngineStatus.value = 'initializing';
isSemanticEngineInitializing.value = true;
semanticEngineInitProgress.value = getMessage('semanticEngineInitializingStatus');
semanticEngineLastUpdated.value = Date.now();
await saveSemanticEngineState();
} else if (status.initializationStatus === 'error') {
semanticEngineStatus.value = 'error';
semanticEngineLastUpdated.value = Date.now();
isSemanticEngineInitializing.value = false;
semanticEngineInitProgress.value = getMessage('semanticEngineInitFailedStatus');
await saveSemanticEngineState();
stopSemanticEngineStatusPolling();
setTimeout(() => {
semanticEngineInitProgress.value = '';
}, 5000);
} else {
semanticEngineStatus.value = 'idle';
isSemanticEngineInitializing.value = false;
await saveSemanticEngineState();
}
} else {
semanticEngineStatus.value = 'idle';
isSemanticEngineInitializing.value = false;
await saveSemanticEngineState();
}
} catch (error) {
console.error('Popup: Failed to check semantic engine status:', error);
semanticEngineStatus.value = 'idle';
isSemanticEngineInitializing.value = false;
await saveSemanticEngineState();
}
};
const retryModelInitialization = async () => {
if (!currentModel.value) return;
console.log('🔄 Retrying model initialization...');
modelErrorMessage.value = '';
modelErrorType.value = '';
modelInitializationStatus.value = 'downloading';
modelDownloadProgress.value = 0;
isModelDownloading.value = true;
await switchModel(currentModel.value);
};
const updatePort = async (event: Event) => {
const target = event.target as HTMLInputElement;
const newPort = Number(target.value);
nativeServerPort.value = newPort;
await savePortPreference(newPort);
};
const checkNativeConnection = async () => {
try {
// eslint-disable-next-line no-undef
const response = await chrome.runtime.sendMessage({ type: 'ping_native' });
nativeConnectionStatus.value = response?.connected ? 'connected' : 'disconnected';
} catch (error) {
console.error('检测 Native 连接状态失败:', error);
nativeConnectionStatus.value = 'disconnected';
}
};
const checkServerStatus = async () => {
try {
// eslint-disable-next-line no-undef
const response = await chrome.runtime.sendMessage({
type: BACKGROUND_MESSAGE_TYPES.GET_SERVER_STATUS,
});
if (response?.success && response.serverStatus) {
serverStatus.value = response.serverStatus;
}
if (response?.connected !== undefined) {
nativeConnectionStatus.value = response.connected ? 'connected' : 'disconnected';
}
} catch (error) {
console.error('检测服务器状态失败:', error);
}
};
const refreshServerStatus = async () => {
try {
// eslint-disable-next-line no-undef
const response = await chrome.runtime.sendMessage({
type: BACKGROUND_MESSAGE_TYPES.REFRESH_SERVER_STATUS,
});
if (response?.success && response.serverStatus) {
serverStatus.value = response.serverStatus;
}
if (response?.connected !== undefined) {
nativeConnectionStatus.value = response.connected ? 'connected' : 'disconnected';
}
} catch (error) {
console.error('刷新服务器状态失败:', error);
}
};
const copyMcpConfig = async () => {
try {
await navigator.clipboard.writeText(mcpConfigJson.value);
copyButtonText.value = '✅' + getMessage('configCopiedNotification');
setTimeout(() => {
copyButtonText.value = getMessage('copyConfigButton');
}, 2000);
} catch (error) {
console.error('复制配置失败:', error);
copyButtonText.value = '❌' + getMessage('networkErrorMessage');
setTimeout(() => {
copyButtonText.value = getMessage('copyConfigButton');
}, 2000);
}
};
const testNativeConnection = async () => {
if (isConnecting.value) return;
isConnecting.value = true;
try {
if (nativeConnectionStatus.value === 'connected') {
// eslint-disable-next-line no-undef
await chrome.runtime.sendMessage({ type: 'disconnect_native' });
nativeConnectionStatus.value = 'disconnected';
} else {
console.log(`尝试连接到端口: ${nativeServerPort.value}`);
// eslint-disable-next-line no-undef
const response = await chrome.runtime.sendMessage({
type: 'connectNative',
port: nativeServerPort.value,
});
if (response && response.success) {
nativeConnectionStatus.value = 'connected';
console.log('连接成功:', response);
await savePortPreference(nativeServerPort.value);
} else {
nativeConnectionStatus.value = 'disconnected';
console.error('连接失败:', response);
}
}
} catch (error) {
console.error('测试连接失败:', error);
nativeConnectionStatus.value = 'disconnected';
} finally {
isConnecting.value = false;
}
};
const loadModelPreference = async () => {
try {
// eslint-disable-next-line no-undef
const result = await chrome.storage.local.get([
'selectedModel',
'selectedVersion',
'modelState',
'semanticEngineState',
]);
if (result.selectedModel) {
const storedModel = result.selectedModel as string;
console.log('📋 Stored model from storage:', storedModel);
if (PREDEFINED_MODELS[storedModel as ModelPreset]) {
currentModel.value = storedModel as ModelPreset;
console.log(`✅ Loaded valid model: ${currentModel.value}`);
} else {
console.warn(
`⚠️ Stored model "${storedModel}" not found in PREDEFINED_MODELS, using default`,
);
currentModel.value = 'multilingual-e5-small';
await saveModelPreference(currentModel.value);
}
} else {
console.log('⚠️ No model found in storage, using default');
currentModel.value = 'multilingual-e5-small';
await saveModelPreference(currentModel.value);
}
selectedVersion.value = 'quantized';
console.log('✅ Using quantized version (fixed)');
await saveVersionPreference('quantized');
if (result.modelState) {
const modelState = result.modelState;
if (modelState.status === 'ready') {
modelInitializationStatus.value = 'ready';
modelDownloadProgress.value = modelState.downloadProgress || 100;
isModelDownloading.value = false;
} else {
modelInitializationStatus.value = 'idle';
modelDownloadProgress.value = 0;
isModelDownloading.value = false;
await saveModelState();
}
} else {
modelInitializationStatus.value = 'idle';
modelDownloadProgress.value = 0;
isModelDownloading.value = false;
}
if (result.semanticEngineState) {
const semanticState = result.semanticEngineState;
if (semanticState.status === 'ready') {
semanticEngineStatus.value = 'ready';
semanticEngineLastUpdated.value = semanticState.lastUpdated || Date.now();
} else if (semanticState.status === 'error') {
semanticEngineStatus.value = 'error';
semanticEngineLastUpdated.value = semanticState.lastUpdated || Date.now();
} else {
semanticEngineStatus.value = 'idle';
}
} else {
semanticEngineStatus.value = 'idle';
}
} catch (error) {
console.error('❌ 加载模型偏好失败:', error);
}
};
const saveModelPreference = async (model: ModelPreset) => {
try {
// eslint-disable-next-line no-undef
await chrome.storage.local.set({ selectedModel: model });
} catch (error) {
console.error('保存模型偏好失败:', error);
}
};
const saveVersionPreference = async (version: 'full' | 'quantized' | 'compressed') => {
try {
// eslint-disable-next-line no-undef
await chrome.storage.local.set({ selectedVersion: version });
} catch (error) {
console.error('保存版本偏好失败:', error);
}
};
const savePortPreference = async (port: number) => {
try {
// eslint-disable-next-line no-undef
await chrome.storage.local.set({ nativeServerPort: port });
console.log(`端口偏好已保存: ${port}`);
} catch (error) {
console.error('保存端口偏好失败:', error);
}
};
const loadPortPreference = async () => {
try {
// eslint-disable-next-line no-undef
const result = await chrome.storage.local.get(['nativeServerPort']);
if (result.nativeServerPort) {
nativeServerPort.value = result.nativeServerPort;
console.log(`端口偏好已加载: ${result.nativeServerPort}`);
}
} catch (error) {
console.error('加载端口偏好失败:', error);
}
};
const saveModelState = async () => {
try {
const modelState = {
status: modelInitializationStatus.value,
downloadProgress: modelDownloadProgress.value,
isDownloading: isModelDownloading.value,
lastUpdated: Date.now(),
};
// eslint-disable-next-line no-undef
await chrome.storage.local.set({ modelState });
} catch (error) {
console.error('保存模型状态失败:', error);
}
};
let statusMonitoringInterval: ReturnType<typeof setInterval> | null = null;
let semanticEngineStatusPollingInterval: ReturnType<typeof setInterval> | null = null;
const startModelStatusMonitoring = () => {
if (statusMonitoringInterval) {
clearInterval(statusMonitoringInterval);
}
statusMonitoringInterval = setInterval(async () => {
try {
// eslint-disable-next-line no-undef
const response = await chrome.runtime.sendMessage({
type: 'get_model_status',
});
if (response && response.success) {
const status = response.status;
modelInitializationStatus.value = status.initializationStatus || 'idle';
modelDownloadProgress.value = status.downloadProgress || 0;
isModelDownloading.value = status.isDownloading || false;
if (status.initializationStatus === 'error') {
modelErrorMessage.value = status.errorMessage || getMessage('modelFailedStatus');
modelErrorType.value = status.errorType || 'unknown';
} else {
modelErrorMessage.value = '';
modelErrorType.value = '';
}
await saveModelState();
if (status.initializationStatus === 'ready' || status.initializationStatus === 'error') {
stopModelStatusMonitoring();
}
}
} catch (error) {
console.error('获取模型状态失败:', error);
}
}, 1000);
};
const stopModelStatusMonitoring = () => {
if (statusMonitoringInterval) {
clearInterval(statusMonitoringInterval);
statusMonitoringInterval = null;
}
};
const startSemanticEngineStatusPolling = () => {
if (semanticEngineStatusPollingInterval) {
clearInterval(semanticEngineStatusPollingInterval);
}
semanticEngineStatusPollingInterval = setInterval(async () => {
try {
await checkSemanticEngineStatus();
} catch (error) {
console.error('Semantic engine status polling failed:', error);
}
}, 2000);
};
const stopSemanticEngineStatusPolling = () => {
if (semanticEngineStatusPollingInterval) {
clearInterval(semanticEngineStatusPollingInterval);
semanticEngineStatusPollingInterval = null;
}
};
const refreshStorageStats = async () => {
if (isRefreshingStats.value) return;
isRefreshingStats.value = true;
try {
console.log('🔄 Refreshing storage statistics...');
// eslint-disable-next-line no-undef
const response = await chrome.runtime.sendMessage({
type: 'get_storage_stats',
});
if (response && response.success) {
storageStats.value = {
indexedPages: response.stats.indexedPages || 0,
totalDocuments: response.stats.totalDocuments || 0,
totalTabs: response.stats.totalTabs || 0,
indexSize: response.stats.indexSize || 0,
isInitialized: response.stats.isInitialized || false,
};
console.log('✅ Storage stats refreshed:', storageStats.value);
} else {
console.error('❌ Failed to get storage stats:', response?.error);
storageStats.value = {
indexedPages: 0,
totalDocuments: 0,
totalTabs: 0,
indexSize: 0,
isInitialized: false,
};
}
} catch (error) {
console.error('❌ Error refreshing storage stats:', error);
storageStats.value = {
indexedPages: 0,
totalDocuments: 0,
totalTabs: 0,
indexSize: 0,
isInitialized: false,
};
} finally {
isRefreshingStats.value = false;
}
};
const hideClearDataConfirmation = () => {
showClearConfirmation.value = false;
};
const confirmClearAllData = async () => {
if (isClearingData.value) return;
isClearingData.value = true;
clearDataProgress.value = getMessage('clearingStatus');
try {
console.log('🗑️ Starting to clear all data...');
// eslint-disable-next-line no-undef
const response = await chrome.runtime.sendMessage({
type: 'clear_all_data',
});
if (response && response.success) {
clearDataProgress.value = getMessage('dataClearedNotification');
console.log('✅ All data cleared successfully');
await refreshStorageStats();
setTimeout(() => {
clearDataProgress.value = '';
hideClearDataConfirmation();
}, 2000);
} else {
throw new Error(response?.error || 'Failed to clear data');
}
} catch (error: any) {
console.error('❌ Failed to clear all data:', error);
clearDataProgress.value = `Failed to clear data: ${error?.message || 'Unknown error'}`;
setTimeout(() => {
clearDataProgress.value = '';
}, 5000);
} finally {
isClearingData.value = false;
}
};
const switchModel = async (newModel: ModelPreset) => {
console.log(`🔄 switchModel called with newModel: ${newModel}`);
if (isModelSwitching.value) {
console.log('⏸️ Model switch already in progress, skipping');
return;
}
const isSameModel = newModel === currentModel.value;
const currentModelInfo = currentModel.value
? getModelInfo(currentModel.value)
: getModelInfo('multilingual-e5-small');
const newModelInfo = getModelInfo(newModel);
const isDifferentDimension = currentModelInfo.dimension !== newModelInfo.dimension;
console.log(`📊 Switch analysis:`);
console.log(` - Same model: ${isSameModel} (${currentModel.value} -> ${newModel})`);
console.log(
` - Current dimension: ${currentModelInfo.dimension}, New dimension: ${newModelInfo.dimension}`,
);
console.log(` - Different dimension: ${isDifferentDimension}`);
if (isSameModel && !isDifferentDimension) {
console.log('✅ Same model and dimension - no need to switch');
return;
}
const switchReasons = [];
if (!isSameModel) switchReasons.push('different model');
if (isDifferentDimension) switchReasons.push('different dimension');
console.log(`🚀 Switching model due to: ${switchReasons.join(', ')}`);
console.log(
`📋 Model: ${currentModel.value} (${currentModelInfo.dimension}D) -> ${newModel} (${newModelInfo.dimension}D)`,
);
isModelSwitching.value = true;
modelSwitchProgress.value = getMessage('switchingModelStatus');
modelInitializationStatus.value = 'downloading';
modelDownloadProgress.value = 0;
isModelDownloading.value = true;
try {
await saveModelPreference(newModel);
await saveVersionPreference('quantized');
await saveModelState();
modelSwitchProgress.value = getMessage('semanticEngineInitializingStatus');
startModelStatusMonitoring();
// eslint-disable-next-line no-undef
const response = await chrome.runtime.sendMessage({
type: 'switch_semantic_model',
modelPreset: newModel,
modelVersion: 'quantized',
modelDimension: newModelInfo.dimension,
previousDimension: currentModelInfo.dimension,
});
if (response && response.success) {
currentModel.value = newModel;
modelSwitchProgress.value = getMessage('successNotification');
console.log(
'模型切换成功:',
newModel,
'version: quantized',
'dimension:',
newModelInfo.dimension,
);
modelInitializationStatus.value = 'ready';
isModelDownloading.value = false;
await saveModelState();
setTimeout(() => {
modelSwitchProgress.value = '';
}, 2000);
} else {
throw new Error(response?.error || 'Model switch failed');
}
} catch (error: any) {
console.error('模型切换失败:', error);
modelSwitchProgress.value = `Model switch failed: ${error?.message || 'Unknown error'}`;
modelInitializationStatus.value = 'error';
isModelDownloading.value = false;
const errorMessage = error?.message || '未知错误';
if (
errorMessage.includes('network') ||
errorMessage.includes('fetch') ||
errorMessage.includes('timeout')
) {
modelErrorType.value = 'network';
modelErrorMessage.value = getMessage('networkErrorMessage');
} else if (
errorMessage.includes('corrupt') ||
errorMessage.includes('invalid') ||
errorMessage.includes('format')
) {
modelErrorType.value = 'file';
modelErrorMessage.value = getMessage('modelCorruptedErrorMessage');
} else {
modelErrorType.value = 'unknown';
modelErrorMessage.value = errorMessage;
}
await saveModelState();
setTimeout(() => {
modelSwitchProgress.value = '';
}, 8000);
} finally {
isModelSwitching.value = false;
}
};
const setupServerStatusListener = () => {
// eslint-disable-next-line no-undef
chrome.runtime.onMessage.addListener((message) => {
if (message.type === BACKGROUND_MESSAGE_TYPES.SERVER_STATUS_CHANGED && message.payload) {
serverStatus.value = message.payload;
console.log('Server status updated:', message.payload);
}
});
};
onMounted(async () => {
await loadPortPreference();
await loadModelPreference();
await checkNativeConnection();
await checkServerStatus();
await refreshStorageStats();
await loadCacheStats();
await checkSemanticEngineStatus();
setupServerStatusListener();
});
onUnmounted(() => {
stopModelStatusMonitoring();
stopSemanticEngineStatusPolling();
});
</script>
<style scoped>
.popup-container {
background: #f1f5f9;
border-radius: 24px;
box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
display: flex;
flex-direction: column;
overflow: hidden;
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
}
.header {
flex-shrink: 0;
padding-left: 20px;
}
.header-content {
display: flex;
justify-content: space-between;
align-items: center;
}
.header-title {
font-size: 24px;
font-weight: 700;
color: #1e293b;
margin: 0;
}
.settings-button {
padding: 8px;
border-radius: 50%;
color: #64748b;
background: none;
border: none;
cursor: pointer;
transition: all 0.2s ease;
}
.settings-button:hover {
background: #e2e8f0;
color: #1e293b;
}
.content {
flex-grow: 1;
padding: 8px 24px;
overflow-y: auto;
scrollbar-width: none;
-ms-overflow-style: none;
}
.content::-webkit-scrollbar {
display: none;
}
.status-card {
background: white;
border-radius: 16px;
box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
padding: 20px;
margin-bottom: 20px;
}
.status-label {
font-size: 14px;
font-weight: 500;
color: #64748b;
margin-bottom: 8px;
}
.status-info {
display: flex;
align-items: center;
gap: 8px;
}
.status-dot {
height: 8px;
width: 8px;
border-radius: 50%;
}
.status-dot.bg-emerald-500 {
background-color: #10b981;
}
.status-dot.bg-red-500 {
background-color: #ef4444;
}
.status-dot.bg-yellow-500 {
background-color: #eab308;
}
.status-dot.bg-gray-500 {
background-color: #6b7280;
}
.status-text {
font-size: 16px;
font-weight: 600;
color: #1e293b;
}
.model-label {
font-size: 14px;
font-weight: 500;
color: #64748b;
margin-bottom: 4px;
}
.model-name {
font-weight: 600;
color: #7c3aed;
}
.stats-grid {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 12px;
}
.stats-card {
background: white;
border-radius: 12px;
box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
padding: 16px;
}
.stats-header {
display: flex;
align-items: center;
justify-content: space-between;
margin-bottom: 8px;
}
.stats-label {
font-size: 14px;
font-weight: 500;
color: #64748b;
}
.stats-icon {
padding: 8px;
border-radius: 8px;
}
.stats-icon.violet {
background: #ede9fe;
color: #7c3aed;
}
.stats-icon.teal {
background: #ccfbf1;
color: #0d9488;
}
.stats-icon.blue {
background: #dbeafe;
color: #2563eb;
}
.stats-icon.green {
background: #dcfce7;
color: #16a34a;
}
.stats-value {
font-size: 30px;
font-weight: 700;
color: #0f172a;
margin: 0;
}
.section {
margin-bottom: 24px;
}
.secondary-button {
background: #f1f5f9;
color: #475569;
border: 1px solid #cbd5e1;
padding: 8px 16px;
border-radius: 8px;
font-size: 14px;
font-weight: 500;
cursor: pointer;
transition: all 0.2s ease;
display: flex;
align-items: center;
gap: 8px;
}
.secondary-button:hover:not(:disabled) {
background: #e2e8f0;
border-color: #94a3b8;
}
.secondary-button:disabled {
opacity: 0.5;
cursor: not-allowed;
}
.primary-button {
background: #3b82f6;
color: white;
border: none;
padding: 8px 16px;
border-radius: 8px;
font-size: 14px;
font-weight: 500;
cursor: pointer;
transition: all 0.2s ease;
}
.primary-button:hover {
background: #2563eb;
}
.section-title {
font-size: 16px;
font-weight: 600;
color: #374151;
margin-bottom: 12px;
}
.current-model-card {
background: linear-gradient(135deg, #faf5ff, #f3e8ff);
border: 1px solid #e9d5ff;
border-radius: 12px;
padding: 16px;
margin-bottom: 16px;
}
.current-model-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 8px;
}
.current-model-label {
font-size: 14px;
font-weight: 500;
color: #64748b;
margin: 0;
}
.current-model-badge {
background: #8b5cf6;
color: white;
font-size: 12px;
font-weight: 600;
padding: 4px 8px;
border-radius: 6px;
}
.current-model-name {
font-size: 16px;
font-weight: 700;
color: #7c3aed;
margin: 0;
}
.model-list {
display: flex;
flex-direction: column;
gap: 12px;
}
.model-card {
background: white;
border-radius: 12px;
padding: 16px;
cursor: pointer;
border: 1px solid #e5e7eb;
transition: all 0.2s ease;
}
.model-card:hover {
border-color: #8b5cf6;
}
.model-card.selected {
border: 2px solid #8b5cf6;
background: #faf5ff;
}
.model-card.disabled {
opacity: 0.5;
cursor: not-allowed;
pointer-events: none;
}
.model-header {
display: flex;
justify-content: space-between;
align-items: flex-start;
}
.model-info {
flex: 1;
}
.model-name {
font-weight: 600;
color: #1e293b;
margin: 0 0 4px 0;
}
.model-name.selected-text {
color: #7c3aed;
}
.model-description {
font-size: 14px;
color: #64748b;
margin: 0;
}
.check-icon {
width: 20px;
height: 20px;
flex-shrink: 0;
background: #8b5cf6;
border-radius: 50%;
display: flex;
align-items: center;
justify-content: center;
}
.model-tags {
display: flex;
align-items: center;
gap: 8px;
margin-top: 16px;
}
.model-tag {
display: inline-flex;
align-items: center;
border-radius: 9999px;
padding: 4px 10px;
font-size: 12px;
font-weight: 500;
}
.model-tag.performance {
background: #d1fae5;
color: #065f46;
}
.model-tag.size {
background: #ddd6fe;
color: #5b21b6;
}
.model-tag.dimension {
background: #e5e7eb;
color: #4b5563;
}
.config-card {
background: white;
border-radius: 16px;
box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
padding: 20px;
display: flex;
flex-direction: column;
gap: 16px;
}
.semantic-engine-card {
background: white;
border-radius: 16px;
box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
padding: 20px;
display: flex;
flex-direction: column;
gap: 16px;
}
.semantic-engine-status {
display: flex;
flex-direction: column;
gap: 8px;
}
.semantic-engine-button {
width: 100%;
display: flex;
align-items: center;
justify-content: center;
gap: 8px;
background: #8b5cf6;
color: white;
font-weight: 600;
padding: 12px 16px;
border-radius: 8px;
border: none;
cursor: pointer;
transition: all 0.2s ease;
box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
}
.semantic-engine-button:hover:not(:disabled) {
background: #7c3aed;
box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
}
.semantic-engine-button:disabled {
opacity: 0.6;
cursor: not-allowed;
}
.status-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 8px;
}
.refresh-status-button {
background: none;
border: none;
cursor: pointer;
padding: 4px 8px;
border-radius: 6px;
font-size: 14px;
color: #64748b;
transition: all 0.2s ease;
}
.refresh-status-button:hover {
background: #f1f5f9;
color: #374151;
}
.status-timestamp {
font-size: 12px;
color: #9ca3af;
margin-top: 4px;
}
.mcp-config-section {
border-top: 1px solid #f1f5f9;
}
.mcp-config-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 8px;
}
.mcp-config-label {
font-size: 14px;
font-weight: 500;
color: #64748b;
margin: 0;
}
.copy-config-button {
background: none;
border: none;
cursor: pointer;
padding: 4px 8px;
border-radius: 6px;
font-size: 14px;
color: #64748b;
transition: all 0.2s ease;
display: flex;
align-items: center;
gap: 4px;
}
.copy-config-button:hover {
background: #f1f5f9;
color: #374151;
}
.mcp-config-content {
background: #f8fafc;
border: 1px solid #e2e8f0;
border-radius: 8px;
padding: 12px;
overflow-x: auto;
}
.mcp-config-json {
font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
font-size: 12px;
line-height: 1.4;
color: #374151;
margin: 0;
white-space: pre;
overflow-x: auto;
}
.port-section {
display: flex;
flex-direction: column;
gap: 8px;
}
.port-label {
font-size: 14px;
font-weight: 500;
color: #64748b;
}
.port-input {
display: block;
width: 100%;
border-radius: 8px;
border: 1px solid #d1d5db;
box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
padding: 12px;
font-size: 14px;
background: #f8fafc;
}
.port-input:focus {
outline: none;
border-color: #8b5cf6;
box-shadow: 0 0 0 3px rgba(139, 92, 246, 0.1);
}
.connect-button {
width: 100%;
display: flex;
align-items: center;
justify-content: center;
gap: 8px;
background: #8b5cf6;
color: white;
font-weight: 600;
padding: 12px 16px;
border-radius: 8px;
border: none;
cursor: pointer;
transition: all 0.2s ease;
box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
}
.connect-button:hover:not(:disabled) {
background: #7c3aed;
box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
}
.connect-button:disabled {
opacity: 0.6;
cursor: not-allowed;
}
.error-card {
background: #fef2f2;
border: 1px solid #fecaca;
border-radius: 12px;
padding: 16px;
margin-bottom: 16px;
display: flex;
align-items: flex-start;
gap: 16px;
}
.error-content {
flex: 1;
display: flex;
align-items: flex-start;
gap: 12px;
}
.error-icon {
font-size: 20px;
flex-shrink: 0;
margin-top: 2px;
}
.error-details {
flex: 1;
}
.error-title {
font-size: 14px;
font-weight: 600;
color: #dc2626;
margin: 0 0 4px 0;
}
.error-message {
font-size: 14px;
color: #991b1b;
margin: 0 0 8px 0;
font-weight: 500;
}
.error-suggestion {
font-size: 13px;
color: #7f1d1d;
margin: 0;
line-height: 1.4;
}
.retry-button {
display: flex;
align-items: center;
gap: 6px;
background: #dc2626;
color: white;
font-weight: 600;
padding: 8px 16px;
border-radius: 8px;
border: none;
cursor: pointer;
transition: all 0.2s ease;
font-size: 14px;
flex-shrink: 0;
}
.retry-button:hover:not(:disabled) {
background: #b91c1c;
}
.retry-button:disabled {
opacity: 0.6;
cursor: not-allowed;
}
.danger-button {
width: 100%;
display: flex;
align-items: center;
justify-content: center;
gap: 8px;
background: white;
border: 1px solid #d1d5db;
color: #374151;
font-weight: 600;
padding: 12px 16px;
border-radius: 8px;
cursor: pointer;
transition: all 0.2s ease;
margin-top: 16px;
}
.danger-button:hover:not(:disabled) {
border-color: #ef4444;
color: #dc2626;
}
.danger-button:disabled {
opacity: 0.6;
cursor: not-allowed;
}
.icon-small {
width: 14px;
height: 14px;
}
.icon-default {
width: 20px;
height: 20px;
}
.icon-medium {
width: 24px;
height: 24px;
}
.footer {
padding: 16px;
margin-top: auto;
}
.footer-text {
text-align: center;
font-size: 12px;
color: #94a3b8;
margin: 0;
}
@media (max-width: 320px) {
.popup-container {
width: 100%;
height: 100vh;
border-radius: 0;
}
.header {
padding: 24px 20px 12px;
}
.content {
padding: 8px 20px;
}
.stats-grid {
grid-template-columns: 1fr;
gap: 8px;
}
.config-card {
padding: 16px;
gap: 12px;
}
.current-model-card {
padding: 12px;
margin-bottom: 12px;
}
.stats-card {
padding: 12px;
}
.stats-value {
font-size: 24px;
}
}
</style>
```