FeHelper: a 30-tool browser extension for JSON, encoding and page debugging

The problem FeHelper solves, and who it is for

Front-end work involves a lot of small, unrelated conversions. You copy a JSON payload out of a network response and want it indented. You have a Unix timestamp and want the date. You need a QR code, a UUID, a color in HSL, or a screenshot of a page that scrolls. Each of those is a separate website, a separate tab, and often a separate upload of data you would rather not paste into an unknown form.

FeHelper's answer is one extension that holds all of them. The README describes it as a browser toolbox aimed at developers, testers, operations staff and efficiency users, with more than 30 tools that can be enabled on demand. The listing covers JSON formatting and diffing, encoding and decoding, timestamp conversion, number base conversion, color conversion, Crontab expressions, code beautifying and minifying, regular expressions, a simple Postman, WebSocket testing, a userscript injector, QR and barcode generation, image to Base64, page screenshots, a color picker, SVG conversion, a page ruler, performance monitoring, UUID and snowflake ID generation, password generation, notes, Markdown conversion, posters and mind maps.

The audience is narrow in a useful way. If your daily work is HTTP APIs and test suites, most of this is already in your editor or terminal. If you spend the day in a browser moving data between pages, forms and dashboards, the tools overlap with what you actually do.

How FeHelper is put together: manifest, service worker, per-tool folders

The repository layout makes the architecture visible. The extension source lives in apps/, and apps/manifest.json is the Chrome Extension Manifest V3 manifest. A background/ directory holds the service worker along with tool registration, menus, statistics and injection logic. popup/ is the toolbar panel and options/ is the settings page and tool marketplace.

Each tool is its own directory next to those: json-format/, json-diff/, en-decode/, datetime-calc/, timestamp/, page-monkey/, poster-maker/, chart-maker/, svg-converter/, uuid-gen/ and others. The README's guidance for adding a tool confirms the pattern: an index.html, index.css and index.js under apps/<tool-name>/, plus a registration entry in apps/background/tools.js and a page under website/docs/<tool-name>.md. That means the tool list is data, not hard-coded UI, and a tool that is not registered will not appear even if its folder exists.

Manifest V3 shapes the runtime. The service worker can be suspended, and the v2026.04 release notes list service worker sleep handling and content script injection strategy as fixes, along with compatibility repairs for sites such as Google Meet. The same notes mention replacing unsafe dynamic execution paths, fixing Toast and innerHTML XSS risks, and adding a fileType allowlist to the code beautifier. Those are the kinds of bugs that come from running a toolbox inside arbitrary pages, and the fact that they are listed as fixed rather than as absent is worth noting.

The README's compatibility table lists the permissions the extension requests: tabs, scripting, contextMenus, storage, webNavigation, notifications and others. The table is truncated at that point, so the full permission set has to be read from apps/manifest.json.

Installing FeHelper from source and formatting JSON the first time

The fastest route is a browser store. The README links Chrome Web Store, Microsoft Edge Add-ons and Firefox Add-ons pages, and the Chrome package ID is pkgccpejnmalmdinmhkkfafefagiiiad. For an offline install it points to Chrome-Stats for a CRX or ZIP that you drag onto the extensions page.

Building from source is a short sequence. The README gives these commands, run from a clone of the repository:

git clone https://github.com/zxlie/FeHelper.git
cd FeHelper
npm install
npm test
npm run build

npm test runs Vitest, and the README states the current suite is 2 test files and 79 tests. npm run build runs the gulp pipeline defined in gulpfile.js and packages the Chrome extension. Do not expect the build to produce a store-ready artifact for every browser; the README describes it as packaging the Chrome extension.

Loading the unpacked build into Chrome or Edge follows the README's four steps: open chrome://extensions/ or edge://extensions/, turn on developer mode, click Load unpacked, and select the apps directory in the repository. Note that this is apps/, not the repository root.

Once loaded, JSON formatting is the tool most people meet first. The README states that the JSON tool detects and formats content on the page automatically, and also supports manual formatting, syntax highlighting, collapsing, sorting, mojibake correction, lossless BigInt handling, nested escape parsing, skin customization, and copy or download. The v2026.04 notes add fixes for repeated auto-formatting of the same content and for repeated mounting of the format container. If you work with large integers, the BigInt path is the one to check first, since ordinary JSON.parse loses precision above 2^53.

Where FeHelper stops being the right tool

The simple Postman is the clearest boundary. The README describes it as GET, POST and HEAD request debugging with JSON result formatting. There is no mention of environments, saved collections, authentication helpers, pre-request scripts or test assertions. If your team already runs a request suite in CI, this tool will not replace it, and using it for anything beyond a one-off call means re-entering the request every time.

The WebSocket tool has the same shape: connect, send a message, inspect the result. That is enough to check whether an endpoint is alive. It is not enough to reproduce a protocol with message ordering, heartbeats or binary frames, and the README does not describe those.

The AI assistant is listed as writing code, changing code, designing approaches and looking up material, with no detail on which model or endpoint it calls, how credentials are handled, or what leaves the browser. The README is silent on all of it. Treat that tool as unverified until you read the source under apps/.

There is also a structural cost. A toolbox that injects into pages will occasionally collide with them, and the release notes show exactly that class of fix: content script injection strategy, Google Meet compatibility, service worker sleep. Each new site is a potential new bug. A single-purpose extension has a smaller surface.

FeHelper versus a dedicated API client such as Postman

The honest comparison is not feature count, it is where the request lives. Postman, Insomnia and similar clients keep requests in a workspace: collections, environments with variables, auth inheritance, and a runner that can execute a folder of requests. FeHelper's simple Postman keeps a request in a tab, and the README gives no indication that requests persist beyond the session.

The difference matters at the boundary. If you need to prove that an endpoint returns a given shape after a deploy, a saved collection plus a runner is the tool. If you need to paste a response body and read it as JSON, the extension is faster than switching applications, and the JSON formatter in FeHelper is a deeper tool than most clients ship: sorting, collapsing, BigInt precision and nested escape parsing are all listed.

The same split applies to encoding. A terminal with base64, openssl and jq covers Unicode, URL, Base64, MD5, SHA1, Hex and Gzip. FeHelper's advantage is that the input is already on screen in the browser, and its JWT, Cookie and HTML entity decoders are the kind of thing you would otherwise search for.

Maintenance, build cost and the MIT licence

The repository is not archived, and the last push was on 2026-09-03, which is recent. The README states the project has run since 2012, and the v2026.04 notes describe an engineering pass: Vitest unit tests, GitHub Actions CI, ESLint, a Babel target raised to Chrome 100, and dependency and dead-code cleanup. Those are the signals of a project that still absorbs maintenance work rather than one that only accumulates features.

The cost of that maintenance lands on you if you fork. The toolchain is gulp 4 with gulp-babel, gulp-uglify-es, gulp-htmlmin, gulp-imagemin and gulp-zip, plus Babel and ESLint as devDependencies. Several of those are old major versions, and package.json carries overrides for fast-xml-parser and postcss, which usually means transitive dependency conflicts were pinned deliberately. Expect the first npm install on a modern Node release to need attention.

The licence is MIT, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are kept. That is a permissive licence, but it is not legal advice, and if you ship a modified build you should read the LICENSE file in the repository rather than this summary. One practical point the README does not address: the extension requests broad permissions, so an internal distribution may need a security review before it reaches users.

Editorial conclusion

Adopt FeHelper if you want JSON formatting, encoding, timestamps and screenshots inside the browser instead of across a dozen tabs, and if you accept that the repository README is a feature matrix rather than a manual. Do not adopt it as a replacement for Postman, Insomnia or a WebSocket client you already script against, because the README describes only GET, POST and HEAD request debugging and leaves authentication, environments and collections undocumented. Before loading it, check the manifest permissions list against your browser policy, and verify the tool you actually need is registered in apps/background/tools.js rather than assuming every row in the feature matrix is enabled by default.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. zxlie/FeHelper on GitHub