Vipe

A safety net for the mistakes AI coding tools make most often. Vipe underlines exposed secrets, missing auth checks, SQL injection and build-breaking mistakes in your JavaScript, TypeScript and SQL as you type. Checking the files you have open runs on your machine, needs no account and sends nothing anywhere.

Vipe Pro scans the whole project and includes more fixes. Not a full security review: no findings does not mean the code is secure.

Pre-release (0.1.x). Expect rough edges. Please tell us what you find at usevipe.com/extension.

What it does

Live detection in the files you have open: red underlines when a check is certain, yellow when it is likely. Runs on your machine, offline, no account, no limit on files.
Whole-project scan (Vipe Pro): files you have not opened, and the checks that compare files. Runs on your machine too.
Files written outside the editor (Vipe Pro lists them): Vipe watches for files written by AI agents, scripts and git, checks them as they land on disk, and shows one notification when a file you have not opened gets a security issue it is certain about. Free counts them.
Fix with Vipe (lightbulb): an AI fix for a security finding, or an exact local edit where one is provably safe. You see the change first, and nothing is applied unless you say yes. After applying, Vipe checks the file again and tells you whether the finding is gone.
Ignore this finding (lightbulb): adds a // vipe-ignore-next-line <rule> comment. Free, offline, no account.

Free and Pro

	Free	Vipe Pro ($12/month)
Live detection in the files you have open (every check decided from one file)	Yes, no account	Yes
Findings in files you have not opened	Counted in the status bar, not listed	Listed in the Problems panel
Checks that compare files: broken imports, unused code, the same route in two files, Supabase row level security across migrations, `.env` files not git-ignored	No	Yes
`Vipe: Scan Workspace`	No	Yes
Fixes (need a signed-in account)	5 to try, of any kind, for the lifetime of the account	300 AI fixes per billing month (fair use, also capped at 50 a day and 30 an hour); build-issue fixes are not counted

Fixes

Fixing needs a signed-in account. Your first 5 fixes are free: security and build-issue fixes count together, once per account, with no monthly reset. After that, fixes are included in Vipe Pro. A fix only counts when it is delivered; if the edit cannot be applied, it is given back.

After a fix is applied, Vipe runs the checks on the file again. Resolved, no new issues is only said when the finding is gone and nothing new appeared. Otherwise Vipe says exactly that and offers Undo. A free fix that did not hold is given back (up to 3 times per account).

What Vipe checks (and what it doesn't)

Vipe checks JavaScript and TypeScript files, SQL files, and environment files (.env). A safety net for the mistakes AI coding tools make most often. Not a full security review, and not a guarantee: no findings does not mean the code is secure.

Some checks are certain and shown as errors. Others are likely, because they depend on something one file does not show, and are shown as warnings.

24 security checks

Check	What it reports	Shown as	Fix
Hardcoded secret (`hardcoded-secret`)	A real key format anywhere in a string (Stripe, OpenAI, Anthropic, GitHub, AWS, a private key, a Supabase service-role key), a secret-named variable holding a random-looking value, or a secret read from the environment with a default written in the code.	error or warning	AI rewrite
Secret exposed to the browser (`public-env-secret`)	A secret behind a prefix that ships it to every visitor (NEXT_PUBLIC_, VITE_, REACT_APP_, EXPO_PUBLIC_), in code or in a .env file.	error or warning	AI rewrite
Service role key in browser code (`service-role-in-client`)	The Supabase service role key, or the admin API that needs it, used in code that runs in the browser.	error	AI rewrite
Secret written to logs (`secret-in-logs`)	A log statement that prints the whole environment or a secret environment variable as it is.	error	exact local edit when one is provably safe
Environment file not git-ignored (`env-not-ignored`)	A .env file with values in it that no .gitignore rule covers, so git would commit it. Editor and CLI only: it needs files that are never uploaded.	error or warning	exact local edit
Table without row level security (`supabase-rls`)	In SQL migrations: a public table that no migration enables row level security for, row level security switched off, or a policy that lets anyone write.	error or warning	exact local edit for a table without row level security
SQL injection (`sql-injection`)	A value spliced into the text of a SQL query instead of being passed as a parameter.	error	AI rewrite
Unverified Stripe webhook (`stripe-webhook-unverified`)	A Stripe webhook handler that acts on an event without verifying its signature.	error or warning	AI rewrite
Server action without an auth check (`server-action-no-auth`)	A Next.js server action that changes data without checking who is calling it.	warning	AI rewrite
Route handler without an auth check (`route-handler-no-auth`)	A Next.js route handler under an admin path, one that changes a record named by the request, or one that hands out a whole table of users or payments, with no check of who is calling.	warning	AI rewrite
Express route without auth (`missing-auth`)	An Express route on a sensitive path with no authentication middleware.	warning	AI rewrite
Token decoded without verification (`jwt-not-verified`)	Server code that decodes a login token without verifying it, or accepts tokens nobody signed.	error or warning	AI rewrite
Insecure session cookie (`insecure-cookies`)	A session or auth cookie set without the httpOnly and secure flags.	error or warning	AI rewrite
Unsanitized HTML (`unsafe-html`)	Content rendered as HTML (dangerouslySetInnerHTML, innerHTML) that is not a fixed string, sanitized or generated.	warning	AI rewrite
Code execution from request input (`eval-injection`)	eval() or new Function() called with something that comes from a request.	error or warning	AI rewrite
Insecure CORS (`insecure-cors`)	Any website allowed to call the API together with cookies or credentials.	error	AI rewrite
Weak password hashing (`weak-password-hashing`)	A password hashed with MD5 or SHA1, or with a fast hash such as SHA-256.	error	AI rewrite
Password compared as plain text (`plaintext-password`)	A stored password compared directly with the one that was typed, which means it is stored unhashed.	warning	AI rewrite
Guessable token (`insecure-random`)	A token, a code or a password made with Math.random(), which can be predicted.	warning	AI rewrite
Open redirect (`open-redirect`)	A redirect to an address taken straight from the request, with nothing checking where it leads.	error or warning	AI rewrite
Server-side request forgery (`ssrf`)	Server code that fetches an address taken straight from the request, so the caller decides which machine the server talks to.	error or warning	AI rewrite
Path traversal (`path-traversal`)	A file read, written or deleted at a path built from a value in the request, with nothing keeping it inside its folder.	error or warning	AI rewrite
Command injection (`command-injection`)	A shell command (exec, execSync) built from a value in the request.	error or warning	AI rewrite
Whole request body stored (`mass-assignment`)	The whole request body written to the database as it came, so the caller chooses which columns are set.	warning	AI rewrite

3 build checks (across files; they run with the workspace scan)

Check	What it reports	Shown as	Fix
Broken import (`broken-import`)	An import of a file or an export that does not exist in the project.	warning	exact local edit when one is provably safe
Duplicate definition (`duplicate-definition`)	The same name declared twice in one file, or the same Express route registered twice.	warning	exact local edit when one is provably safe
Unused code (`dead-code`)	An import that is never used, or a function that nothing in the project references.	warning	exact local edit when one is provably safe

What it does not check

Whether a signed-in user may see or change a particular record (authorization logic).
Authentication done in middleware or in another file: a route that is protected there can still be reported.
Input validation and rate limiting.
A value from the request that passes through a helper function or another file before it is used: redirects, server-side fetches, file paths, shell commands and database writes are only followed inside one function.
Languages other than JavaScript, TypeScript and SQL.
Anything that needs following a value through more than one step of the code.

Test, spec, story, fixture, mock, generated and minified files are not reported on by default (vipe.scanTestFiles turns them on). vipe.exclude lists anything else you want left out.

What is sent to our servers, and when

When	What is sent
Detection (opening, typing, saving, scanning, watching files)	Nothing. It runs on your machine.
Signing in	You sign in with GitHub on usevipe.com in your browser. The extension sends the sign-in code it got back, and your computer's name, so the connected editor has a label in your account. The token is kept in your editor's SecretStorage (your OS keychain).
While signed in	Your token, to ask which plan you have and how many fixes are left. No code.
Fix with Vipe on a security finding	The rule, the file's path relative to your workspace, the line number, the finding's severity, confidence and description, and about 6 lines of code around the finding. Secrets Vipe recognises in those lines (known key formats, private keys, passwords in connection strings, random-looking values in variables named like a secret) are replaced on your machine by a numbered placeholder first. A sensitive value that looks like none of these is sent as written. The server passes the snippet to Anthropic to write the fix.
An exact local fix (a build issue, or a security finding with a mechanical fix)	No code. Only the rule name and an anonymous identifier, so the fix can be counted against your plan.
Signing out	A request that revokes the token.

The server keeps a usage log of AI calls: your account, the rule, the model, token counts, an estimated cost and whether the call produced a usable answer. It holds no code, prompts, replies, file names, line numbers, IP addresses or emails. The extension makes no other network requests and has no analytics or telemetry. Details: Privacy Policy.

Settings

Setting	Default
`vipe.enable`	`true`	Underline problems
`vipe.exclude`	`[]`	Files and folders to report nothing for, as `.gitignore`-style patterns relative to the workspace folder. They are still read, as evidence for the checks that compare files
`vipe.scanTestFiles`	`false`	Also report findings in test, spec, story, fixture, mock and generated files
`vipe.disabledRules`	`[]`	Checks to switch off entirely, by rule id
`vipe.statusBar.show`	`true`	Show the Vipe item in the status bar
`vipe.notifyExternalChanges`	`true`	One notification when a file written outside the editor has a certain security issue (at most one every 10 minutes)
`vipe.scanExternalChanges`	`true`	Check files written by other tools as they land on disk
`vipe.workspaceScan.enabled`	`true`	Scan the whole workspace in the background
`vipe.workspaceScan.maxFiles`	`3000`	Source files the background scan reads per workspace folder
`vipe.workspaceScan.maxFileSizeKB`	`1024`	Files larger than this are not read by the background scan
`vipe.scanOnType` / `vipe.scanOnTypeDelayMs`	`true` / `500`	Re-scan shortly after you stop typing
`vipe.buildability.enable`	`true`	The build checks (broken imports, duplicate definitions, unused code)
`vipe.buildability.maxFiles`	`600`	Skip the checks that compare files above this many source files
`vipe.serverUrl`	`https://www.usevipe.com`	For development. Machine-scoped, so a workspace cannot change where your token is sent

Commands

Vipe: Sign In, Vipe: Sign Out, Vipe: Scan Workspace (Vipe Pro), Vipe: Show Problems, Vipe: See Vipe Pro, Vipe: Open Account.

Editors and platforms

Built for VS Code (1.85 or newer). Cursor, Windsurf, VSCodium and Insiders sign-in supported.

Tested so far: VS Code on Windows. Not tested: macOS, Linux, remote workspaces (SSH, dev containers, WSL), and Cursor, Windsurf and VSCodium themselves. Cursor, Windsurf and VSCodium install from Open VSX.

Restricted Mode and virtual workspaces. Vipe reads files and never runs code from your workspace, so it works in Restricted Mode. In a virtual workspace (for example vscode.dev) it checks the files you open; the background scan and the file watcher need a folder on disk, and signing in is not available in the browser-based editors.

Known limits

Vipe runs inside the editor. There is no terminal-only or command-line mode.
The checks that look across the project are part of Vipe Pro.
Only JavaScript, TypeScript, SQL and .env files are checked.
Fixing needs a signed-in account, and usually a connection; checking needs neither.
A scan is partial when a folder has more source files than vipe.workspaceScan.maxFiles, or a file cannot be read or is over vipe.workspaceScan.maxFileSizeKB. The status bar then says "no issues found (partial scan)" instead of showing a check mark.

Terms · Privacy · usevipe.com/extension