This repository contains the ToS;DR browser extension (Manifest V3) for Chrome, Firefox, and Edge. It downloads a local database of website service ratings from the ToS;DR API, then detects which service a visited domain corresponds to by progressively reducing the hostname. When a match is found, it updates the toolbar icon with the service's grade (A–E) and enables the popup to show detailed summaries of terms-of-service points. The popup also fetches live service details from the API if needed. The codebase is written entirely in TypeScript with strict type checking, uses Vite for building, and includes CI/CD workflows for linting, type-checking, and creating release artifacts. The architecture is a standard single-page browser extension with a background script (or background page for Firefox), popup UI, and settings page. No test suite is present, but the code is well-organized and modular.
Flow Kit is an AI video production pipeline orchestrator that manages the end-to-end workflow of creating cinematic videos via Google Flow. It consists of a FastAPI backend (Python) with SQLite persistence, a React dashboard (TypeScript, shadcn/ui) for monitoring and control, a Chrome MV3 extension that bridges the local agent to flow.google.com for batchexecute RPCs, and a worker queue for asynchronous processing. The system supports project creation, character/entity management, scene image/video generation (Veo 3, Omni Flash), AI-powered video review with contact sheets and dimension scoring, TTS narration via OmniVoice, music generation via Suno API, post-processing (concat, branding, SFX), and YouTube upload with channel rules and SEO metadata. The architecture is modular with a provider abstraction layer (Flow, assistant, muse2api), an event bus for real-time updates, and a skill-based workflow system (40+ markdown recipes) that serves as the single source of truth for AI agents (Claude Code, Codex, agy). The codebase is actively maintained with recent migrations (September 2026 Flow API migration) and a comprehensive test suite, though it carries technical debt from multiple fallback layers, hardcoded payload shapes, and tight coupling to Google Flow's internal API.
Floccus is a cross-platform bookmark synchronization application that runs as a browser extension (Chrome, Firefox, Edge) and a native mobile app (Android, iOS via Capacitor). Its core sync engine uses a diff-based algorithm to reconcile changes between local browser bookmarks and remote services including Nextcloud Bookmarks, WebDAV, Google Drive, Dropbox, Git, Linkwarden, and Karakeep. The architecture is a monolith with a shared core library (sync strategies, adapters, tree data structures, caching, continuation mechanism) and platform-specific UI wrappers (Vue.js options page for the extension, Vue + Vuetify for the mobile app). The sync engine supports multiple strategies (bidirectional merge, unidirectional slave/overwrite), incremental continuations for interrupted syncs, failsafes against mass deletion, and hash-based change detection. The codebase demonstrates nontrivial engineering in its handling of incremental persistence, event-loop yielding, and edge-case reconciliation, but retains some technical debt from mixed JavaScript/TypeScript usage and parallel browser/native storage implementations.
AntiDebug Breaker is a Chrome extension (Manifest V3) designed for JavaScript reverse engineering and penetration testing. It injects over 30 modular hook scripts into web pages to bypass anti-debugging techniques (e.g., `debugger` statements, `console.clear`, time-diff detection), intercept browser APIs (`XMLHttpRequest`, `fetch`, `localStorage`, `sessionStorage`, `JSON.parse`, `JSON.stringify`, `Math.random`, `Date.now`, `performance.now`), and extract cryptographic operations (CryptoJS, JSEncrypt, SM-crypto). It also detects Vue.js and React Router routes by traversing internal DOM fiber trees and exposes them in a popup UI for copying or opening. The extension operates via a background service worker, a content script injected at `document_start`, and a popup interface that allows per-domain or global script toggling with fine-grained configuration (e.g., keyword filtering, value overrides). Each hook script is a self-contained Tampermonkey-style unit that communicates with the extension via `window.postMessage` and `localStorage` flags, making them usable independently outside the extension. The codebase demonstrates strong practical utility for security researchers, but suffers from monolithic popup logic, reliance on brittle internal framework properties, and a lack of automated tests.
Local Browser is a Chrome extension that enables on-device AI-powered web automation using WebLLM. The system implements a two-agent architecture (Planner + Navigator) where users enter natural language tasks in the popup UI, which are then executed through a loop of DOM observation, action planning, and browser interaction. All AI processing occurs locally on the device with no cloud APIs or API keys required. The extension features site-specific state machines for common tasks like Amazon shopping and YouTube navigation (minimizing LLM calls), obstacle detection for login requirements/CAPTCHAs/out-of-stock items, and robust action execution with retry logic and semantic selectors. Built with React, TypeScript, Vite, and CRXJS for MV3 Chrome extension architecture.
Vimium C is a browser extension that provides keyboard-driven navigation and productivity features, forked from Vimium. Its architecture is a classic Chrome/Firefox extension with a background service worker or page, content scripts injected into every page, and extension pages (options, omnibar, show image). The background script manages state, settings, browsing data (history, bookmarks), and orchestrates commands like tab management, URL opening, and synchronization. Content scripts implement the core user-facing features: link hints (detecting clickable elements and overlaying markers), keyboard key handlers with a finite state machine for mapping keystrokes to commands, visual mode for text selection, find-in-page, scrolling with smooth animations, and an omnibar (Vomnibar) for search, history, bookmarks, and command execution. The Vomnibar is a rich UI component that communicates with the background via port messaging. The extension supports multiple browsers (Chrome, Firefox, Edge) and both Manifest V2 and V3, with extensive version-specific conditionals and polyfills. The build system uses TypeScript, gulp, rollup, and terser to produce optimized builds, and includes custom patches to vendored TypeScript and Terser. The codebase demonstrates high engineering effort in handling complex browser quirks and performance optimization, but also carries technical debt from accumulated workarounds and legacy browser support.
CtxPort is a browser extension and companion documentation website that lets users copy AI conversations (from ChatGPT, Claude, Gemini, DeepSeek, Grok, Doubao, GitHub) as structured Markdown Context Bundles. It solves 'context rot' by enabling portable, lossless migration of conversations between AI tools without uploading data to third parties. The architecture is a modern monorepo using pnpm workspaces and Turborepo, with separate packages for schema validation (Zod), markdown serialization, plugin-based extraction, and shared UI components. The browser extension (Manifest V3, WXT, React 19, Tailwind CSS 4) injects copy buttons and sidebar list icons into supported platforms, while the documentation website (Next.js + Nextra) provides multilingual (en/zh) user guides and feature descriptions. All processing is client-side; no data is uploaded. The codebase demonstrates strong engineering practices including a plugin system for extensibility, a strategy pattern for content flatteners, clean separation of concerns, and comprehensive CI/CD pipelines. Some fragility exists in DOM selectors and platform APIs, but the architecture is well-structured for adaptation.
Showdex is a browser extension for Pokémon Showdown that provides a real-time damage calculator (Calcdex) and supplementary tools directly within the battle interface. It integrates deeply with Showdown's client, patching internal classes (Battle, Side, Room) to synchronize all Pokémon, field conditions, and player actions as they occur. The architecture follows a dual-host pattern (legacy Backbone and modern Preact clients) with abstract bootstrappers, React/Redux for UI state, and RTK Query for fetching Pokémon presets from Smogon APIs. It also includes a standalone calculator (Honkdex), a note-taking tool (Notedex), a settings dashboard (Hellodex), and a debug panel (Devdex). The codebase demonstrates strong engineering with well-structured utility modules, custom hooks, drag-and-drop layout components, internationalization (English/French), and a complex hydration/dehydration system for data persistence. While primarily an application, it incorporates significant data processing for Pokémon battle mechanics (stat calculations, legacy DV conversion, preset matching).
Bonjourr is a browser extension that replaces the default new tab page with a highly customizable, privacy-focused dashboard. It is built entirely with TypeScript and Deno (no npm dependencies), using a plain Deno build system to produce extensions for Chrome, Firefox, Edge, Safari, and a PWA version. The code follows a modular feature-dispatcher pattern: each feature (clock, weather, quick links, notes, Pomodoro timer, backgrounds, search bar, quotes, custom CSS, fonts, layout editor) exports an init/update function, allowing clean separation and runtime updates without page reload. A unified storage layer (`storage.ts`) abstracts over `chrome.storage.sync/local` and `localStorage`, while a sophisticated compatibility migration system (`filters.ts`) handles data schema evolution across versions (test configs from v10.0.0 to v20.4.2 confirm backward compatibility). The extension integrates with external APIs (Unsplash, Pixabay, weather.bonjourr.fr, Fontsource, GitHub Gist) for dynamic content and settings sync, but remains opt-in and does not track users. The UI is built with vanilla HTML/CSS, uses CSS custom properties for theming, and includes a full settings panel with help mode for troubleshooting. Despite its large feature set, the architecture remains maintainable through careful abstraction, though some coupling in the main settings module and reliance on third-party services introduce moderate technical drift.
KC3Kai is a mature Chrome extension for the browser game Kantai Collection (KanColle), providing an enhanced game viewer, data analysis, and automation tools. It operates as a DevTools panel and content script, intercepting game API calls to display real-time fleet status, battle predictions, quest tracking, resource graphs, and expedition scoring. The architecture is monolithic with global singletons (KC3Master, KC3SortieManager, PlayerManager) and a tab-based Strategy Room UI for historical data analysis (ship drops, event stats, PvP replays, Akashi improvement planner). It integrates with community databases (TsunDB, PoiDB, KCRDB) for data submission and uses IndexedDB for persistent storage of sorties, battles, and encounters. While primarily an application, it contains significant data analysis components such as battle prediction algorithms, anti-air cut-in calculations, and quest synchronization logic, making it a hybrid tool with strong data engineering aspects.
A browser extension (ImprovedTube) that provides 80+ configuration options to customize YouTube's appearance and behavior. It injects CSS and JavaScript into YouTube pages to modify the player, sidebar, comments, thumbnails, themes, and more. Features include ad blocking, forced playback parameters, keyboard shortcuts, a blocklist for channels/videos, smart speed based on heatmap data, and integration with Return YouTube Dislike. The extension uses a message-passing architecture between content scripts and page-world scripts via custom DOM events, and a custom Satus UI framework for the settings panel. It is localized into 40+ languages but has a high number of open issues and dependencies on fragile YouTube DOM structures. The codebase is functionally comprehensive but shows signs of maintenance drift with hardcoded API keys, heavy use of !important CSS, and incomplete locale coverage.
This is a Chrome extension (Manifest V3) that integrates with the 115.com cloud storage service. It allows users to export download links from their 115 cloud files directly to an aria2 RPC download manager, or to generate text-based download commands for aria2, IDM, or plain links. The extension injects a UI overlay into the 115 web interface (both old and new UI versions) to select files and trigger downloads. It supports recursive folder traversal, SHA1 checksum verification, configurable RPC endpoints, and optional encrypted API calls for premium users. The architecture consists of a background service worker (background.js) that handles messaging, cookie retrieval, and HTTP requests; content scripts (start.js, 115.js, 115_new.js) that run in the context of 115.com pages to intercept file data and communicate with the extension; and a set of library modules (core.js, store.js, ui.js, downloader.js, secret.js) that manage configuration, UI rendering, and download logic. The extension uses a custom RSA-based encryption scheme (secret.js) to interact with 115's pro API for premium download links.
EasySpider is a visual, no-code web scraping tool that combines an Electron desktop application, a Chrome browser extension, and a Python execution engine. Users design scraping workflows via a flowchart-based UI (Vue.js) where they define steps like opening pages, clicking elements, extracting data, looping, and conditional branching. The task definitions are saved as JSON graphs. The Python backend (ExecuteStage) loads these graphs and drives Chrome using Selenium with an undetected-chromedriver fork to evade bot detection. Extracted data can be written to CSV, Excel, JSON, or MySQL. The tool also includes OCR support (ddddocr), custom JavaScript/Python execution, and Cloudflare bypass capabilities. The architecture is a hybrid desktop app with a local HTTP server (Express) that spawns executor processes and communicates via WebSocket. The Chrome extension assists in element selection and XPath generation. While the tool is functional and popular (44k+ stars), the codebase exhibits significant duplication (e.g., identical task files across platform directories, duplicated Bootstrap and content scripts), hardcoded paths, monolithic executor scripts, and mixed-language strings. Several experimental modules (LLM, federated learning) are present but not integrated. The project is actively maintained with recent commits and packaging scripts, but technical debt and drift (Bootstrap 4, Vue 2, pinned Python dependencies) are moderate.
Dejavu is a single-page web application that provides a modern UI for browsing, searching, and managing data in Elasticsearch and OpenSearch clusters. It is built with React 18, Redux, Redux-Saga, and Ant Design, and leverages the ReactiveSearch library for search UI components. The application runs entirely client-side, communicating directly with the Elasticsearch REST API. It supports CRUD operations, data import/export (JSON/CSV), field mapping management, term-based filtering, global search, and a search preview builder. The codebase is organized as a monorepo with two packages: a reusable browser component library (`@appbaseio/dejavu-browser`) and the main application (`dejavu-main`). The architecture follows a standard Redux pattern with sagas for side effects, and uses react-virtualized for high-performance data grids. While the code is well-structured and feature-rich, it relies on several outdated dependencies (Redux 3.x, redux-saga 0.16, react-router-dom 4.x, emotion 9.x) and uses Flow type annotations, which are now deprecated. The project appears to be in a stale maintenance state with no recent commits.
EasySubs is a browser extension for language learning that enhances video watching on platforms like YouTube, Netflix, Coursera, and KinoPub. It provides interactive subtitles with translation capabilities, vocabulary export to learning services (Anki, LinguaLeo, Puzzle English), and UI customization features. The extension uses a content script to modify web pages, a background service worker for cross-tab communication, and a React-based popup for configuration. Built with React/TypeScript, Vite, and Effector for state management, it employs abstraction layers for video platforms, translation services, and learning integrations to handle the complexity of supporting multiple services with frequently changing UIs. The repository also includes a Next.js-based documentation site in the docs/ directory for marketing and user support.
This repository contains the source code for SimpRead (简悦), a browser extension for Chrome and Firefox that provides an immersive reading mode, focus mode, annotation, and later-reading capabilities. The extension extracts article content from web pages, applies customizable typography and themes, and supports exporting to numerous services including Markdown, PDF, EPUB, Kindle, email, and cloud storage (Dropbox, WebDAV, Notion, Evernote, etc.). It includes a rules-based site adaptation engine (defined in `website_list.json`) to handle hundreds of specific websites, a plugin system for user-installed scripts, and a notice/focus system to manage reading sessions. The architecture follows a typical browser extension pattern: a background script (`background.js`) manages storage, OAuth, context menus, and cross-tab communication; content scripts (`contentscripts.js`) inject reading and focus modes into pages; and multiple options pages (`options/`) provide configuration, custom CSS, site management, and notice center. The UI is built with React 0.14.8 and a custom Material Design UI kit (`mduikit`), with heavy use of jQuery for DOM manipulation. State is managed through a central storage service (`storage.js`) that provides reactive reads/writes and versioned migration. External integrations are implemented as service classes with OAuth flows, and a message-action pattern coordinates between isolated script contexts. The codebase demonstrates a strong feature set but suffers from significant technical debt: very old dependencies (webpack 1, React 0.14), deprecated lifecycle patterns, extensive global DOM manipulation mixed with React, hardcoded CDN links and provider secrets, and comments indicating hacky browser workarounds. The site adaptation rule set is large but fragile, relying on exact CSS selectors and inline JavaScript that break when websites change. Despite these issues, the project provides a wealth of reusable patterns, particularly in its custom UI components, notification system, and storage abstraction.
GitHub Hovercard is a browser extension that enhances GitHub with rich hovercards for user profiles, repositories, issues, pull requests, comments, and commits. When hovering over a link on GitHub, it fetches data from the GitHub REST API and displays a tooltip with relevant details such as follower counts, star counts, README previews, issue status, and commit information. The extension also supports authenticated actions like following/unfollowing users and starring/unstarring repositories via a user-supplied access token. The extension is implemented as a monolithic content script that runs on all GitHub pages. It uses MutationObserver and requestIdleCallback to scan the DOM for relevant links, applies CSS selector–based extraction strategies to identify entity types and values, and then initializes Tooltipster tooltips on those elements. Data is fetched via jQuery AJAX and cached per entity type. The UI is rendered using Mustache templates with inline emoji and Octicons. The project includes separate extension packages for Chrome, Firefox, Edge, and Safari, each duplicating core files like jQuery, Mustache, Tooltipster, and the main hovercard script. A userscript variant is also provided. While the extension is functionally complete and has a loyal user base, the codebase exhibits significant technical drift and maintenance risks. Dependencies are outdated (jQuery 3.1.0, Tooltipster 4.0.0rc23), GitHub DOM selectors are fragile and likely to break with UI updates, API preview headers may be deprecated, and the same source files are duplicated across multiple extension directories without a shared build system. No tests are present, and the project appears to have received no recent commits, making it a candidate for forking or modernization.
SharpSilentChrome is a Windows CLI tool that silently installs browser extensions on Google Chrome and Microsoft Edge by directly modifying the browser's 'Preferences' and 'Secure Preferences' files. It implements the technique first published in academic research and popularized by public Python scripts. The tool supports two modes: 'install' which injects an extension and computes the required HMAC integrity checks, and 'revert' which restores backup copies of the preferences files. It can kill and restart browser processes for the target user to apply changes immediately. The code is a C# port of existing Python PoC code, targeting .NET Framework 4.8 with dependencies on Newtonsoft.Json for JSON manipulation and System.Management for WMI process queries. It relies on hardcoded HMAC seeds for Chrome (noted as empty for Edge) and performs SID-to-username resolution via Win32 API and registry. The repository serves primarily as an operational tool for red team exercises, with no unit tests, modular architecture, or reusable components beyond the immediate use case.
InfoSpider is a Windows-only desktop application that aggregates personal data from over 20 online services (e.g., GitHub, JD, Taobao, Alipay, Zhihu, Bilibili) using Selenium-based browser automation and a companion Chrome extension. The user launches a wxPython GUI, selects a data source, logs in via an automated Chrome window, and the tool scrapes orders, bills, contacts, posts, and other personal information, saving it as JSON files. Some spiders also generate HTML charts (word clouds, time-series plots) from the scraped data. The repository includes a separate, experimental PyTorch LSTM model for stock price prediction in `tests/DeepAnalysis/`, which is not integrated into the main tool. The codebase is a monolithic collection of spider scripts with a simple GUI wrapper, relying on outdated library versions (Selenium 3.141.0, pandas 1.0.1) and brittle automation patterns (hardcoded selectors, sleep-based waits). It has not seen active development since 2020 and carries significant technical drift and maintenance risks.
Applicationize is a Node.js/Koa web application that converts web apps into standalone desktop apps by generating Chrome packaged extensions (CRX files). Users input a URL, and the service fetches the web app to extract its title and favicon, then creates a custom Chrome extension that embeds the URL in a webview with native app-like behavior (e.g., keyboard shortcuts for fullscreen, zoom, and dialog handling). The extension is packaged and served as a ZIP file for download to avoid Chrome's CRX_REQUIRED_PROOF_MISSING error. The architecture consists of a server-rendered web interface built with Bootstrap 3 and jQuery, and a backend that handles extension generation via two main routes: one for serving the applicationizer form and another for processing the generation request. The generation process involves fetching the target URL, parsing HTML with Cheerio, generating a self-signed certificate, customizing extension template files (manifest, background script, embed HTML), and packing the extension using the crx and adm-zip modules. Although the code demonstrates clear separation of concerns and includes reusable Koa middleware for HTTPS redirection and error handling, the core functionality is now obsolete due to Google's deprecation of Chrome packaged apps. The project relies on outdated dependencies (including the deprecated request library) and generates extensions using manifest v2 and chrome.app.runtime APIs, which are no longer supported in modern Chrome versions. The README explicitly directs users to alternatives like native application shortcuts or Nativefier, indicating the project is effectively abandoned.