JavaScript · TypeScript

A security scanner that tells you what it did not check.

49 rules over your JavaScript and TypeScript source, entry points recognised by 18 framework adapters, and every candidate exercised against your running application before it is called a finding. It runs locally. The coverage it did not reach is printed in the report, not left for you to assume.

npx myrqen@latest
Recall, held out
0.250
Recall gate
0.90
Uploaded
nothing

What makes this different from the other twelve.

Most scanners in this category match patterns and hand you a list. Three things here are not that.

  • A candidate is not a finding until something exercised it. The static pass produces candidates. Your coding agent settles each one against the running application, under two identities and an admin. The result is verified, strong_evidence or needs_review, and severity is a separate axis: "how bad if real" and "how sure it is real" are different questions.
  • The report states its own coverage. Every report ends with what was not assessed, in the engine's own words. Silence from a scanner is not a clean bill of health, and this one says so in writing.
  • The miss rate is published. Not the flattering number: the one from the corpus nobody had tuned against. Method, corpora, per-class results, raw output.

Every figure above is the static pass alone, scored one file at a time with no agent involved.

What it can see.

A rule is only useful if the engine can find the entry point it applies to. Without an adapter for a framework's route shape there is no handler to follow anything into, which is why the previous release detected far less. These are the shapes recognised today.

SurfaceRecognised
NodeExpress, Fastify, Koa-style handlers, raw http servers, tRPC procedures, GraphQL resolvers
Full-stack frameworksNext.js route handlers and server actions, Nest controllers, Nitro, SvelteKit, Astro, Remix, TanStack/Solid
Alternative runtimesBun.serve, Deno and Deno Fresh, Cloudflare Workers
ServerlessHandler-shaped exports across the common providers
Other surfacesEditor-extension commands and message handlers, desktop CLI entry points, realtime and WebSocket handlers
Data access recognised as a sinkRaw SQL, prepared statements, Drizzle and Kysely fluent builders, Prisma, key-value and document stores

Not recognised: any language other than JavaScript, TypeScript and Python (FastAPI and Flask), template languages, configuration files, and infrastructure definitions. Data flow is followed across functions and modules only where a call resolves, up to four calls deep from a recognised handler; a value that travels through an event emitter, a queue or dynamic dispatch is not connected by the engine, and is handed to your agent instead.

What it found, and what it missed.

Per class, on holdout-3, a 68-case corpus scored blind once and since tuned against: 17 of 34 vulnerable cases detected after the fixes it prompted. The misses stay in the table because they are the useful half.

ClassDetectedCases, filled when detected
missing authentication0 of 2
broken function level authorization0 of 2
business logic price manipulation0 of 1
timing unsafe comparison0 of 1
secret exposed to client bundle0 of 1
stored cross site scripting0 of 1
nosql injection0 of 1
mass assignment0 of 1
broken object level authorization1 of 5
race condition double spend2 of 3
path traversal2 of 3
sql injection4 of 5
server side request forgery4 of 4
command injection2 of 2
prototype pollution1 of 1
insecure cors configuration1 of 1

A class at zero is one this corpus exercised and the engine did not catch. That is fixable work, and until it is done it is a class Myrqen will not find in your code either. The development corpus exercises 38 classes and reports 1.000, which is what a regression gate looks like and says nothing about unseen code.

How you use it.

Reports land in .myrqen/reports/ in the project you scanned, in four formats: self-contained HTML that opens with the network off, JSON, Markdown, and SARIF. They have no expiry, and nothing on our side can remove them.

your terminal

npx myrqen@latest        # detects your coding agents, sets them up
npm run dev                     # start the application you are assessing

/myrqen auto                    # in Claude Code
myrqen auto                    # from Codex, OpenCode, or a plain terminal

Without a coding agent the static pass still runs and still writes all four reports. Every candidate simply stays needs_review, because nobody exercised it. The Claude Code workflow · Codex and OpenCode

When to use something else.

Stated here rather than discovered later.

  • A codebase written mostly in anything other than JavaScript, TypeScript, or a FastAPI or Flask app. Use a mature SAST product.
  • Dependency, licence, or supply-chain inventory. This is not composition analysis.
  • A CI gate that must catch everything. At 0.250 recall it would pass code it should not, and a passing gate reads as a guarantee.
  • A compliance artefact or an audit report. No third party has audited Myrqen.
  • Scanning a deployed production system, or one you do not own. Myrqen exercises the application on your machine and refuses destructive actions, by design.

Common questions.

What is Myrqen?
A local-first application security assessment tool for JavaScript and TypeScript. It runs on your machine, driven by the coding agent you already use, maps the project, exercises candidate vulnerabilities against your running application, and writes HTML, JSON, Markdown and SARIF reports you keep. There is no separate model API key and your repository is not uploaded.
Is Myrqen a SAST tool?
Partly. There is a static pass of 49 rules over your JavaScript and TypeScript source, but a static candidate is not reported as a proven finding until an agent settles it against the running application. Findings that nobody exercised are labelled needs_review rather than presented as certainties.
Does it do software composition analysis?
No. Dependency checks cover a fixed watchlist of commonly used npm packages, from an offline advisory snapshot: installed versions come from your lockfile, and a package is reported only where your own code uses the export an advisory names. Packages outside the watchlist are not checked. If you need dependency and licence inventory, use a dedicated composition analysis product.
Which JavaScript frameworks does it understand?
Express, Fastify, Next.js, Nest, Nitro, SvelteKit, Astro, Remix, TanStack and Solid, tRPC, GraphQL resolvers, Bun.serve, Deno and Deno Fresh, Cloudflare Workers, serverless handlers, editor extensions and desktop CLI entry points. Data access is recognised through raw SQL, prepared statements, Drizzle, Kysely, Prisma and key-value stores.
Which vulnerability classes does it look for?
SQL and NoSQL injection, command and argument injection, code injection, path traversal and zip slip, server-side request forgery, broken object-level and function-level authorization, missing authentication, mass assignment, insecure CORS, open redirect, reflected and stored cross-site scripting, prototype pollution, weak password hashing, timing-unsafe comparison, weak session identifiers, hardcoded secrets, secrets exposed to a client bundle, unrestricted file upload, insecure cookie configuration, verbose error responses, debug endpoint exposure, business-logic price manipulation, and double-spend races. 38 classes are exercised by the development corpus.
How accurate is it?
Precision is 1.000 and the false-positive rate on deliberately correct code is 0.000 on holdout-3 — but only after the fixes its blind run prompted, which burned it as a measurement. On holdout-7, a later corpus scored blind, the false-positive rate on deliberately correct code was 0.125 and 3 of four gates failed. Precision itself is not computable on it: precision is derived from exact class-name matches, and thirty independent authors named the defects in their own vocabulary. The safe-case false-positive rate is the precision signal that survives. Recall is 0.250 on a corpus nobody had tuned against, and the same whether or not a finding is allowed anywhere in the range the case's author marked rather than within eight lines of the line they named. It is the static pass alone, scored one file at a time with no agent involved, against our own gate of 0.90. A report with no findings is not evidence that an application is secure.
Does it upload my source code?
No. There is no code path that uploads your source tree. The only thing that can leave your machine is the finished report, and only if you answer yes to a question asked once per scan. Secret values never appear in a finding, a report, or a progress event at all.
Does it scan Python, Java, Ruby or Go?
Python, for FastAPI and Flask applications; Java, Ruby and Go, no. In full: JavaScript and TypeScript across Node, Bun, Deno and edge runtimes, and Python for FastAPI and Flask applications. Django and other Python frameworks are parsed, but their routes are not modelled, so data-flow checks do not start from them. Java, Ruby, Go, template languages and infrastructure definitions are not parsed at all. For a codebase written mostly in anything else, use a mature SAST product instead.
How much does it cost?
Local scanning, local reports in all four formats, and every finding at every severity are free and unlimited, with no account and no card. Paid plans add cloud sync quota, retention and sharing, from €19 a month.
Is Myrqen open source?
No. The source is published so the engine can be read and audited, under a licence that grants reading and running it for your own work but not redistribution, forks, or hosting it for other people. Please do not describe it as open source.