Skip to main content
Glama
lazaretto-mcp

lazaretto-mcp

Check a whole lockfile for known-malicious dependencies (free, no API key)

check_lockfile

Checks every exactly pinned dependency in a lockfile against known malicious-package advisories, helping you audit dependencies before install or when reviewing an unfamiliar project.

Instructions

Checks every exactly-pinned dependency in a lockfile against published malicious-package advisories (OSV / OpenSSF). One call covers the entire dependency tree.

WHEN TO USE: before installing dependencies, or when auditing a project you did not write. This is the broadest and cheapest check, so start here. Prefer scan_artifact when you need to know what a specific package DOES rather than whether it is already known malware, and scan_lockfile_deep to ask that of every package in the tree. Prefer known_bad_lookup when you already hold a sha256 of a file rather than a lockfile.

COST AND EFFECTS: free, no API key, no payment. Read-only. Reads the lockfile from the working directory itself, so a large lockfile never has to be pasted through the model context. Give packages instead to ask about specific versions, and no lockfile is read.

LIMITS: only exactly-pinned versions can be answered. A range such as ^5.0.0 has no definitive answer, because a compromised release usually sits between clean ones (chalk 5.6.1 was malware while 5.3.0 and later releases were not). Entries with no published registry identity (file:, link:, workspace:, git) are counted under skipped rather than silently dropped.

READING THE RESULT: malicious lists confirmed known-malware versions with advisory ids, and a result with any of them is marked as an error, so act on it rather than summarising it. An empty malicious list is an all-clear ONLY when unverified is also empty AND truncated is false. Anything under unverified could not be checked and must never be reported as clean. truncated: true is worse than that: the lockfile ran past the per-request package limit, and the packages past it are in NEITHER list. They were never looked at, and checked counts only the ones that were. When it is true, run this once per workspace with path, or pass the rest of the tree as lockfile text, before telling anyone the dependencies are clean.

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "check_lockfile"
  }
}

Input Schema

NameRequiredDescriptionDefault
pathNoLockfile path relative to the working directory, e.g. "package-lock.json" or "apps/web/pnpm-lock.yaml". Omit to auto-detect package-lock.json, npm-shrinkwrap.json, yarn.lock, or pnpm-lock.yaml in the working directory. Only those filenames are read.
lockfileNoFull text contents of a lockfile, for when it is not on disk (for example fetched from a PR diff). Supplying this skips reading from disk. Prefer omitting it and letting the tool read the file, which keeps a large lockfile out of the context window.
packagesNoExact name@version identities to check instead of a lockfile, e.g. ["chalk@5.6.1", "@babel/core@7.24.0"]. Use it when you know which versions you care about. Give this or `path` or `lockfile`, not more than one kind: no lockfile is read or sent.

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changedv0.3.1
    • addedInput schema / properties / packages
      Added value: +{
      +  "description": "Exact name@version identities to check instead of a lockfile, e.g. [\"chalk@5.6.1\", \"@babel/core@7.24.0\"]. Use it when you know which versions you care about. Give this or `path` or `lockfile`, not more than one kind: no lockfile is read or sent.",
      +  "items": {
      +    "pattern": "^(?:@[^\\s@/]+\\/)?[^\\s@/]+@\\S+$",
      +    "type": "string"
      +  },
      +  "minItems": 1,
      +  "type": "array"
      +}
  2. First observedv0.3.0

TDQS

A4.8/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries the full burden and does: cost (free, no API key), side effects (read-only, file read from working directory so large lockfiles stay out of context), error signaling (any malicious hit marks the result as an error), and a precise disclosure of the truncation failure mode where packages appear in NEITHER list.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Long but organized into labeled sections (WHEN TO USE, COST AND EFFECTS, LIMITS, READING THE RESULT) with the core purpose front-loaded. Nearly every sentence carries decision-relevant information; the length is justified by the result-interpretation hazards, though the result-reading section could be tightened slightly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a three-parameter tool with no output schema, the description covers everything an agent needs: which inputs are mutually exclusive, what cannot be answered (version ranges, non-registry entries going to `skipped`), and how to interpret `malicious`, `unverified`, `truncated`, and `checked` before declaring dependencies clean.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is already 100%, so the schema documents all three parameters. The description still adds cross-parameter meaning the schema only partly implies: supplying `packages` means no lockfile is read or sent, and `path` can be used to run per-workspace when truncation occurs — useful behavioral coupling rather than restatement.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource (checks every exactly-pinned dependency in a lockfile against malicious-package advisories) plus the scope (whole dependency tree in one call). It names the sibling tools it is not — scan_artifact, scan_lockfile_deep, known_bad_lookup — so the agent can route without opening schemas.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit when-to-use (before installing, auditing foreign projects) and an explicit decision rule against each alternative: scan_artifact for behavior of a specific package, scan_lockfile_deep for behavior of the whole tree, known_bad_lookup when you hold a sha256. It also says to start here because it is the broadest and cheapest check.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.