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

KindWhat it catchesTools (licence)Free or paid, 21 Nov 2026Skylos 5.7.0 in TS/JS
Lint-level rulesRisky calls visible in one file, in the editoreslint-plugin-security (Apache-2.0), typescript-eslint (MIT)FreeSome 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 analysisRequest data reaching SQL, a shell, file paths, URLs or HTMLSemgrep 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 monthYes, inside one handler of one file and its same-file helpers. No cross-file taint
Dependencies (SCA)Published vulnerabilities in npm packagesnpm audit, OSV-Scanner (Apache-2.0)FreeYes: OSV lookups from npm, pnpm, Yarn and Bun lockfiles. Malware advisories are CRITICAL
SecretsKeys and tokens in files and historyGitleaks (MIT), TruffleHog (AGPL-3.0), GitHub secret scanningGitleaks and TruffleHog free. GitHub free on public repos, Secret Protection $19 per active committer per month for privateFiles in the working tree, and server secrets in browser code. Not git history, no live verification
Install-time supply chainMalware, install scripts, typosquats, packages that do not existSocket, Socket Firewall FreeSocket Free plan for 1 seat, Team $25 per seat per month. Firewall Free costs nothingAgent hooks block installs of packages that do not exist, typosquats, versions reported as malware and releases younger than 48 hours
Framework rulesReact, DOM and Next.js APIseslint-plugin-react (MIT), eslint-plugin-no-unsanitized (MPL-2.0)FreeinnerHTML, document.write, dangerouslySetInnerHTML, Next.js API routes with no auth check, SQL in Server Actions
Changes made by coding agentsDeleted or skipped tests, loosened test settings, removed auth middlewareCode review, AI reviewersVariesskylos 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-expression and detect-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 of eval()-like functions"), no-unsafe-argument and no-unsafe-assignment for values typed any, and no-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 .js files and not .ts. The nodejs-extensions option in a .njsscan file 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-level changes that threshold, and npm audit signatures verifies 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.yaml and bun.lock against 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.

AreaWhat Skylos 5.7.0 reports in TS/JSRules
Request data reaching a dangerous callSQL 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 pollutionSKY-D211, D212, D215, D216, D230, D228, D238, D510
Where request data comes fromHandlers in Express, Fastify, Hapi, Koa, NestJS (@Body(), @Query(), @Param() and friends), Next.js pages API and App Router route files, Remix loaders and actionsUsed by the rules above
Risky calls and settingseval, 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 checkSKY-D201, D202, D245, D226, D246, D247, D210, D207, D208, D250, D252, D253, D270, D271, D251, D282
Next.jsAPI routes that change data without checking the user, SQL built in a Server ActionSKY-D280, D281
SecretsKeys and tokens in source and config files, secrets meant for the server, such as process.env.STRIPE_SECRET_KEY, in code bundled for the browserSKY-S101, S102
npm dependenciesPublished 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 reviewSKY-SCA-*, SCA-INT001, SCA-SRC003, SCA-NEW001
AI-code mistakesnpm 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.jsonSKY-D222, D225, L012, Q408
What a change removed or weakenedIn 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 callsSKY-A110, A111, A112, A115, A116, A117, A119, L021
QualityAsync 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 blocksSKY-Q402, Q405, Q406, Q407, Q410, Q301, Q302, Q306, T103 to T106, L035, L007
Dead codeUnused 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_command and 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.name to a SQL string,
  • replaces execFile with an argument array by exec with a template string,
  • puts a Stripe live-format key on line 1 of src/payments.ts (fake, not shown),
  • adds invoice-pdf-stream-kit to package.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/pdf passes req.params.id to renderInvoicePdf() in src/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/refund refunds 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 main and on the branch, Skylos reported ts-jest and jest-junit as unused dependencies (SKY-U005). Both are used, from jest.config.js. package.json cannot hold a comment, so accept findings like these with skylos baseline . and scan with --baseline to gate just the new ones, or turn the rule off with ignore = ["SKY-U005"] in skylos.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:

SituationLintSASTDependenciesSecretsInstall time
Public repository on GitHubeslint-plugin-security, typescript-eslintCodeQL (free on public repos)npm audit or OSV-ScannerGitHub secret scanning (free on public repos)Socket Firewall Free
Private repository, up to 10 contributors, no budgeteslint-plugin-security, typescript-eslintSemgrep's Free Edition (cross-file), or Semgrep CE with no accountOSV-Scanner or npm auditGitleaks as a pre-commit hook and in CISocket Firewall Free
Private repository, larger team with budgetSameGitHub Code Security, Snyk Code, Semgrep Teams or a SonarQube commercial editionThe same vendor's SCA, or OSV-ScannerGitHub Secret Protection, or TruffleHog with verificationSocket

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.