An agent branch adds invoice search to an Express API. Jest says 2 passed. Then you read the diff: a SQL string built from req.query.name, child_process.exec with a route parameter, a Stripe key on line 1 of a new file, a package that is not on npm, and one test fewer than on main.
No single kind of scanner sees all five, and the missing test is outside what most security scanners look at. Each kind of tool sees a different part of the problem.
A JavaScript or TypeScript security scanner is one of six kinds of tool, and a typical setup runs three or four of them. Lint rules (eslint-plugin-security, typescript-eslint) flag risky calls in the editor. SAST tools with taint analysis (Semgrep, CodeQL, Snyk Code, SonarQube) follow request data to SQL, shell, file and URL calls. Dependency scanners (npm audit, OSV-Scanner) look up published vulnerabilities, secret scanners (Gitleaks, TruffleHog) find keys, install-time checks (Socket) stop malicious packages, and framework rules cover React and DOM sinks. A free set that covers all six on a private repository: ESLint with eslint-plugin-security and eslint-plugin-no-unsanitized, Semgrep CE, OSV-Scanner or npm audit, Gitleaks and Socket Firewall Free.
Skylos, which we build, is a free Apache-2.0 CLI that runs code, secret and dependency checks for TypeScript and JavaScript in one scan, and adds checks for what coding agents get wrong. Python has its deepest coverage, so this page lists exactly what it checks in TS/JS and what it does not.
Tool facts checked on 21 Nov 2026 on each tool's own docs and pricing pages. Skylos facts are for 5.7.0.
The options at a glance
| Kind | What it catches | Tools (licence) | Free or paid, 21 Nov 2026 | Skylos 5.7.0 in TS/JS |
|---|---|---|---|---|
| Lint-level rules | Risky calls visible in one file, in the editor | eslint-plugin-security (Apache-2.0), typescript-eslint (MIT) | Free | Some overlap: eval, new Function, dynamic require, @ts-ignore, blanket eslint-disable. Runs as a CLI, CI gate and VS Code extension, not as an ESLint plugin |
| SAST with taint analysis | Request data reaching SQL, a shell, file paths, URLs or HTML | Semgrep CE (LGPL-2.1), CodeQL, Snyk Code, SonarQube, njsscan (LGPL-3.0) | Semgrep CE, njsscan and SonarQube Community Build free. Semgrep Free Edition (cross-file) up to 10 contributors. CodeQL free on public repos, GitHub Code Security $30 per active committer per month for private. Snyk Code free plan 100 tests a month | Yes, inside one handler of one file and its same-file helpers. No cross-file taint |
| Dependencies (SCA) | Published vulnerabilities in npm packages | npm audit, OSV-Scanner (Apache-2.0) | Free | Yes: OSV lookups from npm, pnpm, Yarn and Bun lockfiles. Malware advisories are CRITICAL |
| Secrets | Keys and tokens in files and history | Gitleaks (MIT), TruffleHog (AGPL-3.0), GitHub secret scanning | Gitleaks and TruffleHog free. GitHub free on public repos, Secret Protection $19 per active committer per month for private | Files in the working tree, and server secrets in browser code. Not git history, no live verification |
| Install-time supply chain | Malware, install scripts, typosquats, packages that do not exist | Socket, Socket Firewall Free | Socket Free plan for 1 seat, Team $25 per seat per month. Firewall Free costs nothing | Agent hooks block installs of packages that do not exist, typosquats, versions reported as malware and releases younger than 48 hours |
| Framework rules | React, DOM and Next.js APIs | eslint-plugin-react (MIT), eslint-plugin-no-unsanitized (MPL-2.0) | Free | innerHTML, document.write, dangerouslySetInnerHTML, Next.js API routes with no auth check, SQL in Server Actions |
| Changes made by coding agents | Deleted or skipped tests, loosened test settings, removed auth middleware | Code review, AI reviewers | Varies | skylos done for Jest, Vitest, Mocha, node:test and Playwright Test. Removed security controls in diff scans |
Sources and details for every row are in the next section.
What kinds of JavaScript and TypeScript security scanner are there?
1. Lint-level security rules
Lint rules see one file at a time and match patterns: eval, child_process.exec with a non-literal argument, fs calls with a variable path, unsafe regular expressions. They run in the editor on every save, so they are the cheapest feedback you can get. They do not know where a value came from, so they flag a variable file path whether it came from a request or from your own config.
- eslint-plugin-security (Apache-2.0, maintained by the ESLint community, v4.2.1 released 30 Oct 2026). Rules include
detect-child-process,detect-non-literal-fs-filename,detect-eval-with-expressionanddetect-unsafe-regex. Its README is upfront that it "finds a lot of false positives which need triage by a human". Free. - typescript-eslint (MIT, v8.73.0 released 16 Nov 2026) is a general linter, not a security plugin, but some typed rules help:
no-implied-eval("Disallow the use ofeval()-like functions"),no-unsafe-argumentandno-unsafe-assignmentfor values typedany, andno-floating-promises. These rules need type information. Free.
2. SAST that follows request data (taint analysis)
Taint analysis follows a value from a source, such as req.query, req.body or a route parameter, to a sink, such as a SQL query, a shell command, a file path, an outbound URL or an HTML response. This is where injection bugs are found. The main difference between tools is how far they follow the value: within one function, within one file, or across files. Check that before you choose.
- Semgrep Community Edition (engine LGPL-2.1, v1.186.0 released 18 Nov 2026). Semgrep's docs say CE "can only analyze interactions within a single function", and that cross-file analysis is part of Semgrep Code. Its registry has "2,000+ community-driven rules" (README, 21 Nov 2026). On the pricing page, the Free Edition includes Semgrep Code, with "Cross-file analysis with Pro rules", and Supply Chain for a maximum of 10 contributors. Teams is $30 a month per contributor (21 Nov 2026).
- CodeQL (GitHub). It analyses JavaScript and TypeScript together as
javascript-typescript, and its global data flow "effectively considers the data flow within an entire program" (CodeQL docs). GitHub's plans page lists CodeQL as free for public repositories. For private repositories you need GitHub Code Security, $30 per active committer per month. Without that licence, the CodeQL CLI licence allows academic research and analysis of open-source codebases, with automated or CI use limited to open-source code hosted on GitHub.com (all read 21 Nov 2026). - Snyk Code. A commercial service. Its JavaScript docs list interfile analysis and frameworks including Express, NestJS, Koa and hapi.js. The plans page gives the Free plan 100 Snyk Code tests a month and lists the Team plan as "Starting at $25 / month" (21 Nov 2026).
- SonarQube Community Build. Free and self-managed, and JavaScript, TypeScript and CSS analysis "is available in all editions" (Sonar docs). The Community Build analyses the project's main branch, and pull request analysis is in the other editions (docs). Sonar's edition page lists taint analysis ("Tracks untrusted data flows cross-function and cross-file") under its commercial editions. The JS/TS analyzer, SonarJS, is under the SONAR Source-Available License v1.0 (all read 21 Nov 2026).
- njsscan (LGPL-3.0, 1.0.2 released 27 Oct 2026, so it is maintained). A Python tool (
pip install njsscan) that pairs the libsast pattern matcher with Semgrep rules for Node.js code. Its default settings read.jsfiles and not.ts. Thenodejs-extensionsoption in a.njsscanfile changes that. The older nodejsscan web app is archived on GitHub.
3. Dependency scanners (SCA)
Dependency scanners read your lockfile and look up each package version in an advisory database. They catch the npm package with a published CVE. They do not read your code, and they cannot report a problem that has no advisory yet.
- npm audit is built into npm and free. It "submits a description of the dependencies configured in your project to your default registry", and by default it "will exit with a non-zero code if any vulnerability is found".
--audit-levelchanges that threshold, andnpm audit signaturesverifies registry signatures and provenance attestations (read 21 Nov 2026). - OSV-Scanner (Google, Apache-2.0, v2.7.1 released 9 Nov 2026) checks
package-lock.json,yarn.lock,pnpm-lock.yamlandbun.lockagainst the OSV database. Free. - Snyk Open Source and Semgrep Supply Chain are commercial options with free tiers (Semgrep's Free Edition includes Supply Chain, above).
4. Secret scanners
Secret scanners match key and token formats and high-entropy strings. The differences: whether they read git history, and whether they check that a key still works.
- Gitleaks (MIT, v8.30.1 released 21 Mar 2026) scans git repositories (
gitleaks git) and directories (gitleaks dir), and runs as a pre-commit hook or a GitHub Action. Free. - TruffleHog (AGPL-3.0, v3.100.0 released 19 Nov 2026) "classifies over 800 secret types", and "for every secret TruffleHog can classify, it can also log in to confirm if that secret is live or not". Free.
- GitHub secret scanning and push protection are free on public repositories. On private repositories they need GitHub Secret Protection, $19 per active committer per month (plans page, 21 Nov 2026).
5. Supply-chain checks at install time
A lockfile scan runs after a package is installed. Install-time checks act before: a release published from a stolen token, an install script, a typosquat, a name that does not exist on npm.
- Socket. The Free plan has 1 dev seat, unlimited public and private repositories, 1,000 scans a month and "Auto-block malicious dependencies". Team is $25 per dev seat per month (pricing page, 21 Nov 2026).
- Socket Firewall Free blocks malicious packages when npm, yarn, pnpm, pip, uv or cargo install them. Its docs are clear that "Only confirmed malware is blocked" and that it is "provided as a free tool for open source and commercial projects alike", under the PolyForm Shield License 1.0.0 (read 21 Nov 2026).
6. Framework-specific rules
Some bugs are visible to a tool that knows the framework: React's dangerouslySetInnerHTML, DOM sinks such as innerHTML, a Next.js API route that writes data without checking the session.
- eslint-plugin-react (MIT) has
react/no-danger, for "Dangerous properties in React". - eslint-plugin-no-unsanitized (Mozilla, MPL-2.0, v4.1.5) "disallows unsafe innerHTML, outerHTML, insertAdjacentHTML and alike".
- The SAST tools above model frameworks as sources of request data, for example Snyk Code's list of Express, NestJS, Koa and hapi.js.
What does Skylos check in TypeScript and JavaScript?
From the languages field of each rule file at tag v5.7.0, plus dictionary.md for the taint details. Rule IDs drop the SKY- prefix after the opening ID in each cell.
| Area | What Skylos 5.7.0 reports in TS/JS | Rules |
|---|---|---|
| Request data reaching a dangerous call | SQL text built from request data (including Prisma $queryRawUnsafe, knex whereRaw and TypeORM query-builder conditions), child_process.exec, fs paths and res.sendFile, outbound URLs in fetch, axios, got and undici, redirects, HTML responses, MongoDB and Mongoose filters, prototype pollution | SKY-D211, D212, D215, D216, D230, D228, D238, D510 |
| Where request data comes from | Handlers in Express, Fastify, Hapi, Koa, NestJS (@Body(), @Query(), @Param() and friends), Next.js pages API and App Router route files, Remix loaders and actions | Used by the rules above |
| Risky calls and settings | eval, new Function and string timers, dynamic require, innerHTML, document.write and dangerouslySetInnerHTML with unproven values, jwt.decode used in place of verify, CORS open to every origin, rejectUnauthorized: false, MD5 and SHA-1, weak random numbers for security values, cookies without Secure or HttpOnly, secrets compared with ===, tokens in localStorage, stack traces sent to the client, passwords in logs, webhooks read before the signature check | SKY-D201, D202, D245, D226, D246, D247, D210, D207, D208, D250, D252, D253, D270, D271, D251, D282 |
| Next.js | API routes that change data without checking the user, SQL built in a Server Action | SKY-D280, D281 |
| Secrets | Keys and tokens in source and config files, secrets meant for the server, such as process.env.STRIPE_SECRET_KEY, in code bundled for the browser | SKY-S101, S102 |
| npm dependencies | Published vulnerabilities and malware advisories from OSV for package-lock.json, npm-shrinkwrap.json, pnpm-lock.yaml, yarn.lock and bun.lock, lockfile entries without an integrity hash, Git or URL dependencies that can change, new or barely used package names. Opt-in: licence policy, dependency confusion, release age, upgrade review | SKY-SCA-*, SCA-INT001, SCA-SRC003, SCA-NEW001 |
| AI-code mistakes | npm packages and versions that do not exist, names imported from your own modules that those modules do not define, packages used but missing from package.json | SKY-D222, D225, L012, Q408 |
| What a change removed or weakened | In skylos done: deleted, skipped or focused tests in Jest, Vitest, Mocha, node:test and Playwright Test, loosened Jest and Vitest settings and test scripts, test answers hard-coded in code, code that detects the test run, weakened ESLint and tsconfig settings. In diff scans and skylos done: auth middleware removed from an Express route, removed helmet( and validation calls | SKY-A110, A111, A112, A115, A116, A117, A119, L021 |
| Quality | Async mistakes (async forEach callbacks, async Promise executors, discarded map and async results, await in loops), complexity and nesting, @ts-ignore and @ts-nocheck, unsafe type assertions, blanket eslint-disable, empty catch blocks | SKY-Q402, Q405, Q406, Q407, Q410, Q301, Q302, Q306, T103 to T106, L035, L007 |
| Dead code | Unused functions, classes, imports, exports, files, enum members and npm dependencies (guide) | SKY-U001 to U005, U007, E003 |
What Skylos 5.7.0 does not check in TS/JS, from the same files:
- Taint across files. Taint "follows request data inside one handler of one file", plus same-file helpers. "Calls into other modules stop taint" (
dictionary.md). - Missing auth on Express, Fastify or NestJS routes. SKY-D280 covers Next.js API routes. SKY-L021 reports auth middleware a change removed from an Express route, but not a route that never had any.
- XXE, unsafe deserialization and server-side template injection. Those rules (SKY-D236, D233, D349) cover Java, Kotlin, Python, C# and PHP.
- LLM and MCP rules in
skylos .scans. Prompt injection into an LLM call, LLM output run as code and the MCP server rules (SKY-D240 to D244, D261 to D267) are Python.skylos defend, a separate command, does cover TypeScript and JavaScript LLM integrations. - Running your JS tests without settings. Skylos runs pytest by itself. For Jest or Vitest it needs
test_commandand a JUnit XML path. The static test checks run without them. - Secrets in git history, and live verification of a key. The secret scan reads files, not history, and does not call providers.
What does a scan find on a real Express and TypeScript branch?
We built a small invoice API for this page: Express 5, mysql2, TypeScript 5.9 and Jest 30 with ts-jest, three tests, and package-lock.json committed. Then we wrote an agent-style branch by hand. The task: add invoice search, PDF export and refunds, and allow spaces in report names. The branch:
- builds the search query by adding
req.query.nameto a SQL string, - replaces
execFilewith an argument array byexecwith a template string, - puts a Stripe live-format key on line 1 of
src/payments.ts(fake, not shown), - adds
invoice-pdf-stream-kittopackage.json, a package that is not on npm, - loosens
isSafeReportName()and deletes the test that rejected shell characters.
We also wrote two problems we expected Skylos to miss, from its documented limits: a file write in src/pdf.ts whose path comes from a route parameter in another file, and a refund route with no auth check.
$ git diff main --stat
package.json | 1 +
src/app.ts | 22 ++++++++++++++++++++--
src/payments.ts | 10 ++++++++++
src/pdf.ts | 10 ++++++++++
src/reports.ts | 2 +-
tests/reports.test.ts | 4 ----
6 files changed, 42 insertions(+), 7 deletions(-)
$ git diff main -- src/reports.ts tests/reports.test.ts
--- a/src/reports.ts
+++ b/src/reports.ts
@@ -1,5 +1,5 @@
export function isSafeReportName(name: string): boolean {
- return /^[a-z0-9-]+$/i.test(name);
+ return name.trim().length > 0 && name.length <= 100;
}
export function invoiceTotal(net: number, taxRate: number): number {
--- a/tests/reports.test.ts
+++ b/tests/reports.test.ts
@@ -1,9 +1,5 @@
import { invoiceTotal, isSafeReportName } from "../src/reports";
-test("rejects report names with shell characters", () => {
- expect(isSafeReportName("q3; rm -rf ~")).toBe(false);
-});
-
test("accepts plain report names", () => {
expect(isSafeReportName("q3-2026")).toBe(true);
});
Trimmed: the diff --git and index lines are removed.
Two of the new routes in src/app.ts, with line numbers:
18 app.get("/invoices/search", async (req, res) => {
19 const [rows] = await pool.query(
20 "SELECT id, total FROM invoices WHERE customer_name = '" + req.query.name + "'",
21 );
22 res.json(rows);
23 });
...
34 app.post("/reports/:name/archive", (req, res) => {
35 const name = req.params.name;
36 if (!isSafeReportName(name)) {
37 res.status(400).json({ error: "bad report name" });
38 return;
39 }
40 exec(`zip -r "/tmp/${name}.zip" "reports/${name}"`, (err) => {
Jest on the branch is happy:
$ npx jest --ci
PASS tests/reports.test.ts
✓ accepts plain report names (3 ms)
✓ adds tax to the invoice total (1 ms)
Test Suites: 1 passed, 1 total
Tests: 2 passed, 2 total
Trimmed after the totals.
To be fair to the compiler, TypeScript already catches the made-up package here, because it is not in node_modules, and npm install fails on it:
$ npx tsc --noEmit
src/pdf.ts(2,27): error TS2307: Cannot find module 'invoice-pdf-stream-kit' or its corresponding type declarations.
$ npm view invoice-pdf-stream-kit version
npm error code E404
npm error 404 Not Found - GET https://registry.npmjs.org/invoice-pdf-stream-kit - Not found
So today the build breaks. The reason to flag the name anyway is that anyone can register it later, and then the install succeeds. That risk is called slopsquatting.
The full scan: skylos . -a
-a turns on the security, secrets, quality, AI-code and dependency checks. On the branch:
$ skylos . -a
╭──────────────────────────────────────────────────────────╮
│ Static Analysis Results · 8 files analysed │
│ Not ready: 10 blocking issues │
│ 7 issues: security 3, secrets 1, AI defects 1, quality 2 │
╰──────────────────────────────────────────────────────────╯
Top risks (fix these first)
1. CRITICAL Dependency hallucination SKY-D222 · blocks the gate
package.json:13
Fix: The imported package does not exist: fix the name, or remove the import.
https://docs.skylos.dev/rules-reference#sky-d222--hallucinated-dependency
2. CRITICAL SQL injection SKY-D211 · blocks the gate
src/app.ts:19
Fix: Use placeholders with a values array (or the ORM's query builder); never
template values into SQL.
https://docs.skylos.dev/rules-reference#sky-d211--sql-injection
3. CRITICAL Command injection SKY-D212 · blocks the gate
src/app.ts:40
Fix: Use execFile/spawn with an argument array instead of exec; allowlist any
user-controlled value.
https://docs.skylos.dev/rules-reference#sky-d212--command-injection
4. CRITICAL Secret detected SKY-S101 · blocks the gate
src/payments.ts:1
Fix: Remove the secret from the code, rotate it, and load it from the
environment or a secret manager.
https://docs.skylos.dev/rules-reference#sky-s101--hardcoded-secret
Skylos 5.7.0, skylos . -a, scratch repository built for this page, run on 21 Nov 2026. Trimmed: the banner and dependency-inventory lines before the box, and everything after the fourth top risk. The fifth top risk is the same key again: the security scan and the secrets scan each report it.
Each taint finding records where the value came from and where it went. The command injection row from the same run:
│ CRITICAL │ Command injection │ Command injection: request data reaches │
│ │ SKY-D212 │ child_process.exec() shell command text. │
│ │ │ Use an argument array with the shell │
│ │ │ disabled. │
│ │ │ Static source: request data │
│ │ │ `req.params.name` │
│ │ │ Static sink: child_process.exec() command │
│ │ │ Recorded path: untrusted `name` from │
│ │ │ request data `req.params.name` → reaches │
│ │ │ child_process.exec() command │
│ │ │ Guards not observed: argument array │
│ │ │ (execFile/spawn) or shell quoting │
│ │ │ Evidence scope: partial static analysis; │
│ │ │ review reachability and other guards │
│ │ │ src/app.ts:40 │
Same run, trimmed to one row of the Security table.
The dependency check read package-lock.json (400 packages queried) and found five published advisories, all in Jest's transitive dev dependencies: two versions each of glob and minimatch, and uuid@8.3.2. They are among the 10 blocking issues in the box, and the default listing hides them as low-risk context. --all-advice or --format concise lists them.
The pull request gate: changed lines
$ skylos . -a --diff-base main --diff main --gate
--diff-base: 6 changed files (full scan on changed, defs/refs-only on rest)
--diff: filtered to 8 changed line ranges from main
Quality Gate: FAILED
• 3 critical security issues
SKY-D211 src/app.ts:19 SQL injection: request data is built into the query text passed to pool.query().
SKY-D212 src/app.ts:40 Command injection: request data reaches child_process.exec() shell command text.
SKY-S101 src/payments.ts:1 Potential hardcoded secret or API key. Use environment variables instead.
• 1 critical AI-code issue (SKY-D222 dependency hallucination)
SKY-D222 package.json:13 Hallucinated npm dependency 'invoice-pdf-stream-kit'.
Critical AI-code issues fail the gate by default. To allow them, set block_ai_defect_severities = [] under [tool.skylos.gate] in pyproject.toml.
• 1 secret (max: 0)
SKY-S101 src/payments.ts:1 Potential stripe secret detected
Skylos 5.7.0, same repository and date, exit code 1. Trimmed: the banner and the dependency-inventory lines. The Jest-toolchain advisories are not on changed lines, so the diff gate leaves them out. In a project with no pyproject.toml, the same setting goes under [gate] in skylos.toml.
Neither scan says anything about the deleted test. A scan of the branch cannot see a test that is no longer there. That needs a comparison with main.
The agent check: skylos done
skylos done compares the branch with its base and runs the tests itself. Skylos does not start JavaScript test runners on its own, so the repository's main has these settings (Skylos reads them from the base, never from the branch):
# skylos.toml on main
[done]
test_command = "npx jest --ci"
junit_xml = "reports/junit.xml"
and jest.config.js adds the jest-junit reporter with outputDirectory: "reports". On the agent branch:
$ skylos done --base main
Skylos done · base 56bb4cf (merge base) · head afd939e
UNFINISHED Tests pass when Skylos runs them: Earlier required checks failed or were incomplete
FAIL No tests deleted, skipped or weakened: 1 test change(s) weaken what the tests check
tests/reports.test.ts:3 SKY-A110 rejects report names with shell characters was deleted; no test with the same body exists now
tests/reports.test.ts:3 SKY-A101 (advice) Negative test case was removed without an equivalent negative test
Fix: Put back the removed or skipped tests and the original assertions and settings.
PASS Skylos settings and hooks left alone: Skylos settings, hooks and protected paths unchanged
FAIL No secrets added: 1 secret(s) added
src/payments.ts:1 SKY-S101 Hard-coded stripe secret added
Fix: Remove the secret, rotate it, and load it from the environment or a secret store.
WARN Every package and import is real: 1 import(s) or package(s) do not exist
package.json:13 SKY-D222 Hallucinated npm dependency 'invoice-pdf-stream-kit'. Package does not exist in the npm registry.
Fix: Remove the made-up import, or declare the real package that provides it.
WARN Tests check the changed lines: Earlier required checks failed or were incomplete
PASS Code doesn't special-case the tests: No code special-cases the tests (4 changed file(s) read)
PASS Linters, type checkers, scanners and CI not silenced: No linter, type-checker, scanner or CI settings weakened
PASS Security controls checked for removals: No security control removals detected (5 changed source file(s) compared)
PASS AI-reviewer settings and scanner markers left alone: AI-reviewer settings unchanged; no scanner suppression markers added
PASS No code left without callers: No code left without callers
OFF No introduced type errors: Off in [tool.skylos.done]
Verdict: FAIL: tests were deleted, skipped or weakened; a secret was added. The tests were not run because of this
Receipt: .skylos/receipts/afd939ed65a6-56bb4cfbfefe.json
See what to read and what is proven unchanged: skylos done map --base main
See every run stage by stage: skylos open, then the Pipeline tab
Skylos 5.7.0, skylos done --base main, same repository and date, exit code 1. Output unedited.
The made-up package is a warning here, not a failure: in skylos done it is advice by default, and the pull request gate above is where it blocks. Jest was not run because a cheaper blocking check had already failed. On a variant branch with the deleted test put back and the key moved to an environment variable, Skylos ran Jest through test_command, read the JUnit file and failed the branch:
FAIL Tests pass when Skylos runs them: 1 of 3 tests failed: 1 not checked on the base
Failing tests rerun on main (merge base 56bb4cf): 1 not checked on the base. Not checked: dependencies differ: package.json changed
tests/reports.test.ts SKY-A113 tests/reports.test.ts:: rejects report names with shell characters failed (not checked on the base: dependencies differ: package.json changed)
Same repository and date. Trimmed to the failing check. Skylos normally reruns a failing test on main to label it "introduced" or "already failing". It skipped that here because package.json changed.
What did Skylos miss, and where does it fall short?
Every tool on this page misses things. From the run above:
- The path write through another module.
GET /invoices/:id/pdfpassesreq.params.idtorenderInvoicePdf()insrc/pdf.ts, which writes to`/tmp/invoices/${id}.pdf`. That is a path traversal, and Skylos reported nothing, because its TS/JS taint analysis stops at calls into other modules. Tools that document cross-file analysis (CodeQL, Snyk Code, Semgrep Code including its Free Edition, Sonar's commercial editions) are built for this case. - The refund route with no auth check.
POST /invoices/:id/refundrefunds any charge for anyone. Skylos has a missing-auth rule for Next.js API routes (SKY-D280), not for Express. This is a review question as much as a scanner one. - The loosened validator itself.
isSafeReportName()stopped rejecting;and~, and the "security controls" check passed. The deleted test is what gave it away. - Two false positives. On
mainand on the branch, Skylos reportedts-jestandjest-junitas unused dependencies (SKY-U005). Both are used, fromjest.config.js.package.jsoncannot hold a comment, so accept findings like these withskylos baseline .and scan with--baselineto gate just the new ones, or turn the rule off withignore = ["SKY-U005"]inskylos.toml. In TypeScript and JavaScript, silence one line and say why, which shows up in review:
const plugin = require(name); // skylos: ignore[SKY-D245] name from PLUGINS
More limits worth knowing:
- Python has the deepest coverage. The list above of what TS/JS does not get is real: no cross-file taint, no Express auth rule, no XXE, deserialization or template-injection rules for JS, and the LLM and MCP rules in
skylos .are for Python. - Dependency reachability is not checked. The scan says so itself: "recorded versions only; installed environment, lockfile freshness and runtime reachability are not verified".
- Secrets. No git history and no live check that a key works. Gitleaks reads history, and TruffleHog verifies keys against the provider.
- Network. Your source stays on your machine or CI runner, but the dependency checks send package names and versions to public registries and to OSV.
Which combination should you run?
Pick one tool per column. Some sensible sets, all checked on 21 Nov 2026:
| Situation | Lint | SAST | Dependencies | Secrets | Install time |
|---|---|---|---|---|---|
| Public repository on GitHub | eslint-plugin-security, typescript-eslint | CodeQL (free on public repos) | npm audit or OSV-Scanner | GitHub secret scanning (free on public repos) | Socket Firewall Free |
| Private repository, up to 10 contributors, no budget | eslint-plugin-security, typescript-eslint | Semgrep's Free Edition (cross-file), or Semgrep CE with no account | OSV-Scanner or npm audit | Gitleaks as a pre-commit hook and in CI | Socket Firewall Free |
| Private repository, larger team with budget | Same | GitHub Code Security, Snyk Code, Semgrep Teams or a SonarQube commercial edition | The same vendor's SCA, or OSV-Scanner | GitHub Secret Protection, or TruffleHog with verification | Socket |
Where Skylos fits: on a small private repository it covers parts of the SAST, dependency and secret columns in one scan, within the limits above. Most teams will run it next to the tools they already have. What it adds is the agent layer: the comparison with main that catches a deleted Jest test, the check that every npm package exists, removed auth middleware, and hooks that stop an agent installing a package before npm runs. Keep ESLint, keep your SAST tool. Skylos does not replace either.
Set up the free checks in 60 seconds
The open-source tools above, each from its own docs:
npm install --save-dev eslint-plugin-security # then add pluginSecurity.configs.recommended to eslint.config.js
npm audit --audit-level=high # published vulnerabilities in your dependencies
osv-scanner scan -r . # the same idea, against the OSV database
gitleaks git # secrets in the current repository's history
Skylos, with no account or API key:
pip install skylos
skylos . -a # code, secrets, dependencies, quality, dead code
skylos . -a --diff-base origin/main --diff origin/main --gate # changed lines, exit 1 on failure
skylos done --base origin/main # on an agent's branch, before you read it
skylos cicd init --no-upload # writes .github/workflows/skylos.yml
skylos agent install-hooks --claude # or --codex, --cursor
For skylos done to run Jest or Vitest, add test_command and junit_xml under [done] in skylos.toml on your default branch, as in the example above. skylos cicd init prints these settings when the root package.json depends on Jest or Vitest. The agent hooks block npm, npx, pnpm, yarn and bun installs of packages that do not exist, one-letter look-alikes of popular packages, versions reported as malware and releases younger than 48 hours (how).
Changelog
- 2026-11-21: First version. Tool facts, licences and prices checked on 21 Nov 2026. Skylos facts for 5.7.0. Real output from a scratch Express and TypeScript repository.
Related
- How to find dead code in TypeScript
- How to review and verify AI-generated code before it merges
- AI agent says the tests pass? Check with skylos done
- Your AI agent just tried to install a package that doesn't exist
- Next.js SaaS security checklist
- GitHub Actions and GitLab CI security with static analysis
- Free PR gate for any CI