osv-scanner-mcp 0.3.4 → 0.4.0

package/README.md

@@ -5,13 +5,14 @@
 [![license](https://img.shields.io/npm/l/osv-scanner-mcp)](LICENSE)
 [![node](https://img.shields.io/node/v/osv-scanner-mcp)](package.json)
 
-Google製 [OSV-Scanner](https://github.com/google/osv-scanner) をラップするMCPサーバーです。Claude等のMCPクライアントから「このJavaプロジェクトの脆弱性をチェックして」と自然言語で依頼するだけで、依存ライブラリの既知の脆弱性(CVE / GHSA)を深刻度順のレポートで取得できます。
+Google製 [OSV-Scanner](https://github.com/google/osv-scanner) をラップするMCPサーバーです。Claude等のMCPクライアントから「このプロジェクトの脆弱性をチェックして」と自然言語で依頼するだけで、依存ライブラリの既知の脆弱性(CVE / GHSA)を深刻度順のレポートで取得できます。
 
-> **ステータス**: [npmで公開中](https://www.npmjs.com/package/osv-scanner-mcp)(`npx -y osv-scanner-mcp`)。Maven(pom.xml)と Gradle(gradle.lockfile / lockfile方式)に対応しています。MCPクライアントは Claude Code / Claude Desktop / Codex CLI / Antigravity / VS Code(GitHub Copilot)での利用手順を用意しています。
+> **ステータス**: [npmで公開中](https://www.npmjs.com/package/osv-scanner-mcp)(`npx -y osv-scanner-mcp`)。Java(Maven / Gradle)、JavaScript(npm / yarn / pnpm / bun)、Python(Poetry / uv / Pipenv / PDM / requirements.txt)、Go のlockfileに対応しています(修正版の推奨はJavaのみ)。MCPクライアントは Claude Code / Claude Desktop / Codex CLI / Antigravity / VS Code(GitHub Copilot)での利用手順を用意しています。
 
 ## 特徴
 
-- **ワンショットスキャン**: `scan_java_project` ツールにプロジェクトパスを渡すだけで、検出→スキャン→整形済みレポートまで一気に返します
+- **複数言語のワンショットスキャン**: `scan_project` ツールにプロジェクトパスを渡すだけで、Java・JavaScript・Python・Goのlockfileを検出してまとめてスキャンします。lockfileが無い・バージョンが未固定などでスキャンできなかった依存は、応答先頭の `coverage` で明示します
+- **Javaプロジェクトのスキャン**: `scan_java_project` ツールでJava(Maven / Gradle)のマニフェストだけを対象に、検出→スキャン→整形済みレポートまで一気に返します
 - **JAR/WAR実体スキャン**: `scan_java_artifact` ツールで、lockfileが無い・shaded/fat JARしか手元にないプロジェクトでもアーカイブ内メタデータから既知の脆弱性を検出します(ベストエフォート同定であることを明示するcoverage情報付き)
 - **SBOM入力スキャン**: `scan_sbom` ツールでCycloneDX/SPDXのJSON SBOMに記録された依存を検査します。SBOMの網羅性や実成果物との一致は未検証であることを明示します
 - **深刻度順のレポート**: パッケージごとに脆弱性をCVSSスコア順に整理し、5段階の深刻度ラベル(critical / high / medium / low / unknown)とサマリ集計付きで返します
@@ -123,7 +124,7 @@ npm run build
 | `OSV_MCP_MAX_CONCURRENT_SCANS` | 同時実行できるスキャン数の上限(デフォルト `2`、最大 `16`)。超過したリクエストは待たずに即時エラーになります |
 | `OSV_MCP_AUTO_DOWNLOAD` | `0` または `false` でバイナリの自動ダウンロードを無効化(デフォルト有効) |
 | `OSV_MCP_PREFER_DOWNLOAD` | `1` または `true` 指定時、PATH上のosv-scannerを使わず、チェックサム検証済みの自動ダウンロードバイナリを常に使用します(PATH汚染による偽バイナリ実行の防止。`OSV_SCANNER_PATH` の明示指定は引き続き最優先) |
-| `OSV_MCP_NO_REMOTE_RESOLUTION` | `1` または `true` 指定時、`pom.xml` の推移的依存を deps.dev で解決しません。**止まるのは deps.dev への送信だけで、脆弱性照会のためパッケージの名前とバージョンは引き続き `api.osv.dev` に送られます**。推移的依存の脆弱性は検出できなくなり、その旨が応答の `dependency_resolution.warning` に示されます。詳細は[通信先とプライバシー](#通信先とプライバシー) |
+| `OSV_MCP_NO_REMOTE_RESOLUTION` | `1` または `true` 指定時、`pom.xml` と `requirements.txt` の推移的依存を deps.dev で解決しません。**止まるのは deps.dev への送信だけで、脆弱性照会のためパッケージの名前とバージョンは引き続き `api.osv.dev` に送られます**。推移的依存の脆弱性は検出できなくなり、その旨が応答の `dependency_resolution.warning` に示されます。詳細は[通信先とプライバシー](#通信先とプライバシー) |
 
 > **推奨**: `OSV_MCP_ALLOWED_ROOT` は未設定でも動作しますが、その場合は任意の絶対パスをスキャンできてしまいます。悪意ある指示(プロンプトインジェクション)経由で意図しないディレクトリをスキャンさせられる経路を塞ぐため、プロジェクト置き場のルート(例: `~/projects`)を設定しておくことを推奨します。各クライアントの設定で `"env": {"OSV_MCP_ALLOWED_ROOT": "/Users/you/projects"}` のように渡せます(Codex CLIのTOMLでは `[mcp_servers.osv-scanner.env]` セクション)。
 
@@ -140,19 +141,79 @@ osv-scanner v2.4.0 で接続先を実機確認した結果です(2026-10-07)。
 
 | 操作 | 接続先 | 送られる情報 |
 |---|---|---|
-| `pom.xml` のスキャン(`scan_java_project` / `suggest_fix`) | `api.osv.dev`、**`api.deps.dev`** | パッケージの名前とバージョン。deps.dev には推移的依存の解決のため、`pom.xml` に宣言された依存(社内パッケージを含む)の名前とバージョンが送られます |
-| `gradle.lockfile` のスキャン | `api.osv.dev` | パッケージの名前とバージョン(lockfileに全依存が記載済みのため、解決のための外部接続はしません) |
+| `pom.xml` のスキャン(`scan_project` / `scan_java_project` / `suggest_fix`) | `api.osv.dev`、**`api.deps.dev`** | パッケージの名前とバージョン。deps.dev には推移的依存の解決のため、`pom.xml` に宣言された依存(社内パッケージを含む)の名前とバージョンが送られます |
+| `requirements.txt` のスキャン(`scan_project`) | `api.osv.dev`、**`api.deps.dev`** | `pom.xml` と同じく、推移的依存の解決のため記載された依存の名前とバージョンが deps.dev に送られます。`--index-url` 等に書かれた取得先へは接続しません |
+| lockfileのスキャン(`gradle.lockfile`、`package-lock.json` 等のnpm系、`poetry.lock` 等のPython系、`go.mod`) | `api.osv.dev` | パッケージの名前とバージョン(lockfileに全依存が記載済みのため、解決のための外部接続はしません) |
 | `scan_java_artifact` / `scan_sbom` | `api.osv.dev` | 同定できたパッケージの名前とバージョン |
 | `explain_vulnerability` | `api.osv.dev` | 指定した脆弱性ID |
 | バイナリの自動ダウンロード(初回のみ) | GitHub(公式Releases) | なし(ピン留めしたバージョンのバイナリを取得) |
 
 api.osv.dev と deps.dev はどちらも Google が運営するサービスです。**どの設定でも、スキャンしたパッケージの名前とバージョンは脆弱性照会のため `api.osv.dev` に送られます**(オフラインでの照会には対応していません)。
 
-- **deps.dev への送信を止めたい場合**: `OSV_MCP_NO_REMOTE_RESOLUTION=1` を設定すると、`pom.xml` の推移的依存を解決しなくなり、接続先は `api.osv.dev` だけになります。止まるのは deps.dev への送信だけで、OSV への送信は続きます。また `pom.xml` に直接書いた依存しかスキャンされず、**推移的依存の脆弱性を見落とします**。この状態は `scan_java_project` / `suggest_fix` の応答の `dependency_resolution` に `transitive_resolution: "disabled"` と警告で示されるので、検出0件と区別できます。推移的依存も含めて deps.dev を使わずにスキャンするには、Gradleのlockfile方式(`gradle.lockfile`)を使ってください
+- **deps.dev への送信を止めたい場合**: `OSV_MCP_NO_REMOTE_RESOLUTION=1` を設定すると、`pom.xml` と `requirements.txt` の推移的依存を解決しなくなり、接続先は `api.osv.dev` だけになります。止まるのは deps.dev への送信だけで、OSV への送信は続きます。また直接書いた依存しかスキャンされず、**推移的依存の脆弱性を見落とします**。この状態は `scan_project` / `scan_java_project` / `suggest_fix` の応答の `dependency_resolution` に `transitive_resolution: "disabled"` と警告で示されるので、検出0件と区別できます。推移的依存も含めて deps.dev を使わずにスキャンするには、lockfile方式(`gradle.lockfile`、`poetry.lock` 等)を使ってください
 - **任意の取得先には接続しません**: osv-scanner の `--data-source native` モードは、スキャン対象の `pom.xml` の `<repositories>` に書かれた任意のURLへ接続します(悪意あるpom.xmlで攻撃者のサーバーへ通信させられる)。本サーバーはこのモードを使わず、`deps.dev` を明示指定しています
 
 ## 提供ツール
 
+### `scan_project`
+
+プロジェクト内のlockfile・マニフェストを検出し、Java / JavaScript / Python / Go の依存をまとめてスキャンします。パッケージマネージャーやビルドは実行しません。
+
+**入力**
+
+| パラメータ | 型 | 説明 |
+|---|---|---|
+| `project_path` | string | スキャン対象のプロジェクトディレクトリ、または対応するlockfile・マニフェストの絶対パス(直接指定したファイルはそれ1件だけをスキャン) |
+
+**対応ファイル**
+
+| エコシステム | ファイル |
+|---|---|
+| Java(Maven) | `pom.xml`、`gradle.lockfile`、`buildscript-gradle.lockfile` |
+| JavaScript(npm) | `package-lock.json`、`npm-shrinkwrap.json`、`yarn.lock`、`pnpm-lock.yaml`、`bun.lock`(テキスト形式) |
+| Python(PyPI) | `poetry.lock`、`uv.lock`、`Pipfile.lock`、`pdm.lock`、`requirements.txt`(`requirements-dev.txt` 等も) |
+| Go | `go.mod` |
+
+`.git`、`node_modules`、`target`、`build`、`.venv`、`venv`、`site-packages`、`__pycache__`、`.tox`、`vendor` とシンボリックリンクは探索しません。検出したファイルだけを形式を明示してOSV-Scannerに渡します(応答の `coverage.manifests` がそのままスキャン範囲です)。探索上限は `scan_java_project` と同じです。
+
+**requirements.txtは元のファイルをOSV-Scannerに渡しません**。本サーバーが解析し、解釈できた依存の行だけを `名前==版` 等の単純な形に直して専用の一時コピーに書き、それをスキャンします(スキャン後に削除)。OSV-Scannerは取り込み指定を独自に解釈してたどる(`- r ../x.txt` のような空白入りも取り込みとみなし、スキャン範囲の外のファイルを読む)ため、コピーには取り込み指定やオプションを一切含めません。取り込み(`-r` / `--requirement`)は、プロジェクトディレクトリ内の取り込み先だけを本サーバーが展開してコピーに含めます。
+
+**出力の読み方**
+
+```json
+{
+  "project_dir": "/path/to/project",
+  "dependency_resolution": { "transitive_resolution": "enabled" },
+  "coverage": {
+    "complete": false,
+    "warning": "一部の依存はスキャンされていないか、版を推測してスキャンしています(…)",
+    "manifests": [{ "path": "web/package-lock.json", "ecosystem": "npm", "format": "package-lock.json" }],
+    "lockfile_missing": [{ "path": "svc/package.json", "ecosystem": "npm", "status": "missing", "hint": "lockfileがありません。…" }],
+    "unpinned_requirements": [{ "file": "py/requirements.txt", "line": 2, "name": "Jinja2", "specifier": ">=2.0", "kind": "lower_bound" }],
+    "unscannable_requirements": [
+      { "file": "py/requirements.txt", "line": 4, "text": "-e git+https://…", "reason": "編集可能インストール(-e)はスキャンされません" },
+      { "file": "py/requirements.txt", "line": 5, "text": "-r ../shared/base.txt", "reason": "取り込み先がプロジェクトディレクトリの外のため展開しません" }
+    ],
+    "skipped_files": []
+  },
+  "ecosystem_breakdown": { "npm": { "manifests": 1, "vulnerable_package_count": 2, "vulnerability_count": 4 } },
+  "vulnerable_package_count": 2,
+  "vulnerability_count": 4,
+  "severity_breakdown": { "critical": 0, "high": 2, "medium": 2, "low": 0, "unknown": 0 },
+  "packages": [{ "name": "minimist", "version": "1.2.5", "ecosystem": "npm", "dependency_groups": ["dev"], "vulnerabilities": [] }]
+}
+```
+
+- **`coverage` を必ず確認してください**。`complete: false` の場合、一部の依存はスキャンされていないため、検出0件でも安全とは言えません
+  - `lockfile_missing`: lockfileの無いマニフェスト(`package.json`、`pyproject.toml`、`Pipfile`、`setup.py`、`build.gradle` 等)。同じディレクトリに同じエコシステムのlockfileがあれば記録しません。上位のディレクトリのlockfileだけがある場合は、`package-lock.json`(v2以降)にそのディレクトリが収録されていることを確認できたときだけ記録しません(npm workspaces)。収録されていなければ `status: "missing"`、確認できない形式(yarn.lock、Python系等)なら `status: "unconfirmed"` として記録します。`hint` の手順でlockfileを生成してから再スキャンしてください(生成は信頼できる環境で)
+  - `unpinned_requirements`: requirements.txtのうち、版を固定していない行。`kind` は `unpinned`(版の指定なし)・`range`(`>`、`<`、`!=`、`==1.*`、範囲の組み合わせ等)・`lower_bound`(`>=`、`~=`)。`unpinned` と `range` の行はOSV-Scannerがスキャンせず、`lower_bound` の行は下限の版を使用中の版とみなしてスキャンします(該当パッケージには `version_is_lower_bound: true` が付き、実際の版とは異なる可能性があります)
+  - `unscannable_requirements`: スキャンされない行と理由。`-e`、`name @ URL`、パス指定、展開しなかった取り込み(プロジェクトディレクトリの外・存在しない・URL・上限超過)、制約ファイル(`-c`、適用しません)、解釈できないオプションや版の指定。解釈できない行は無視せず、ここに記録します
+  - `skipped_files`: スキャン対象から外したファイルと理由(requirements.txt自体が読めない・1MiBを超える場合、`pom.xml` の親POMが許可ルートの外を参照する場合。後者は[親POMの扱い](#親pomの扱い)を参照)
+  - 各一覧は200件までで、超えた分の件数を `omitted_items` に返します
+- `ecosystem_breakdown` は、脆弱性0件のエコシステムも含めて「スキャンした」ことを示します
+- `dependency_groups` はOSV-Scannerが付けた依存グループ(例: `dev`)の生の値です。lockfileの形式によって欠落・不正確なため(pnpmでは付かず、pdmでは `optional` になる等)、参考情報として扱ってください
+- 修正版の推奨(`suggest_fix`)は現在Javaのみ対応です
+
 ### `scan_java_project`
 
 Java(Maven)プロジェクトをスキャンし、既知の脆弱性レポートを返します。
@@ -167,6 +228,20 @@ Java(Maven)プロジェクトをスキャンし、既知の脆弱性レポート
 
 > **スキャン範囲**: ディレクトリを指定すると、配下の `pom.xml` / `gradle.lockfile` / `buildscript-gradle.lockfile` を深さに関係なく検出し、**検出したファイルだけ**をスキャンします(応答の `manifests` がそのままスキャン範囲です)。同じディレクトリにある `package-lock.json` や `requirements.txt` などJava以外のファイルはスキャンしません。`.git`、`node_modules`、`target`、`build`、`.idea`、`.vscode` とシンボリックリンクは探索しません。探索するエントリが20万件、またはマニフェストが1,000件を超える場合は、結果を黙って省略せず `manifest_search_limit_exceeded` を返します。`pom.xml` などのマニフェストを直接指定した場合は、ディレクトリを探索せず**そのファイルだけ**をスキャンします(上限に達した場合の回避手段としても使えます)。
 
+#### 親POMの扱い
+
+OSV-Scannerは `pom.xml` の `<parent>` が参照する親POM(`<relativePath>` の指すファイル。省略時はMavenの既定どおり `../pom.xml`)を読み、親の親もたどって、そこに書かれた依存を結果に含めます。サブモジュールだけをスキャンしても親から引き継いだ依存を検出できるのはこのためです。
+
+`OSV_MCP_ALLOWED_ROOT` を設定している場合、親POMの連鎖のどこかが**許可ルートの外**のファイルを参照する `pom.xml` は、スキャン対象から外します(許可ルート外のファイルの内容を結果や照会先に出さないため)。外したファイルは応答の `skipped_manifests`(`scan_project` では `coverage.skipped_files`)に理由付きで示し、`scope_warning` で「検出0件でも安全とは判断しない」旨を伝えます。全件が外れた場合や、該当する `pom.xml` を直接指定した場合は `path_outside_allowed_root` を返します。
+
+- 許可ルート内の親POMは従来どおり読みます(サブモジュールのスキャンは許可ルート内なら引き続き使えます)
+- `<relativePath/>`(空)はローカルの親POMを参照しないため対象外です
+- 親POMの指定は、OSV-Scanner(Go)のXMLの解釈に合わせて読みます。要素は名前空間の接頭辞に関係なく要素名で照合し(`<m:parent>` も親として扱う)、ルート要素の直下の `parent` だけを対象にし、文字参照を展開します
+- XMLの仕様どおり、解析前に改行(CRLF・CR)をLFに正規化します
+- 同じ解釈を保証できない場合は除外します: ルート直下の `parent` や `relativePath` が複数ある、CDATA・DOCTYPE・未知の実体参照・プロパティ参照(`${...}`)がある、タグが閉じていない、UTF-8として読めない、`relativePath` に制御文字(改行・タブ等)・通常の空白以外の空白・書式文字が含まれる(通常の空白や日本語のディレクトリ名は使えます)
+- 親のGAVが一致しなければOSV-Scannerは読みませんが、本サーバーはGAVを確認せず、許可ルートの外に参照先のファイルがあれば安全側に除外します
+- `OSV_MCP_ALLOWED_ROOT` が未設定の場合は任意の絶対パスをスキャンできる状態のため、この検証は行いません
+
 **出力(成功時)**
 
 ```json
@@ -334,7 +409,7 @@ OSV-Scanner 2.4.0の `java/archive` プラグインを使用し、ネストJAR
 | `binary_download_failed` | バイナリのダウンロード失敗(未対応プラットフォーム含む) |
 | `binary_checksum_mismatch` | ダウンロードしたバイナリのチェックサム不一致(改ざん/破損の可能性) |
 | `gradle_lockfile_missing` | Gradleプロジェクトだがgradle.lockfileが無い(生成手順をmessageで案内) |
-| `path_outside_allowed_root` | `OSV_MCP_ALLOWED_ROOT` の外を指している |
+| `path_outside_allowed_root` | `OSV_MCP_ALLOWED_ROOT` の外を指している(マニフェストの親POMが許可ルートの外を参照し、スキャンできるマニフェストが残らない場合を含む) |
 | `no_packages_found` | スキャン対象パッケージなし(依存関係が未定義のpom.xml等) |
 | `scan_failed` | OSV-Scannerが異常終了(stderr抜粋を`detail`に含む) |
 | `scan_timeout` | タイムアウト(デフォルト120秒) |
@@ -352,7 +427,7 @@ OSV-Scanner 2.4.0の `java/archive` プラグインを使用し、ネストJAR
 
 - **サプライチェーン対策**: バイナリの自動ダウンロードは公式GitHub Releasesに限定し、バージョンをピン留め。**パッケージに埋め込まれたSHA256チェックサム**で検証します(配布元のSHA256SUMSファイルは信用しないため、リリース側が改ざんされても検出可能)。検証合格まで実行権限を与えず、キャッシュ済みバイナリも使用のたびに再検証します。`OSV_MCP_PREFER_DOWNLOAD=1` でPATH上の未検証バイナリを使わない運用も選べます
 - **コマンドインジェクション対策**: シェルを経由しない `spawn` + 引数配列で実行。OSV-Scannerへの引数は固定リストのみで、可変部は検証済み絶対パス1つだけ
-- **パストラバーサル対策**: 入力パスは `realpath` でシンボリックリンク解決後に境界チェック。pom.xml探索ではシンボリックリンクを辿りません。OSV-Scannerにはディレクトリを渡さず、検出したマニフェストだけを形式を明示して個別に渡します(ディレクトリを渡すと、OSV-Scannerが同じディレクトリの `requirements.txt` も読み、その取り込み指定 `-r ../x.txt` でスキャン範囲の外のファイルを読むため)
+- **パストラバーサル対策**: 入力パスは `realpath` でシンボリックリンク解決後に境界チェック。pom.xml探索ではシンボリックリンクを辿りません。OSV-Scannerにはディレクトリを渡さず、検出したマニフェストだけを形式を明示して個別に渡します(ディレクトリを渡すと、OSV-Scannerが同じディレクトリの `requirements.txt` も読み、その取り込み指定 `-r ../x.txt` でスキャン範囲の外のファイルを読むため)。`scan_project` でrequirements.txtをスキャンする場合は元ファイルを渡さず、解釈できた依存の行だけを正規化して書いた専用コピーをスキャンします。コピーには取り込み指定を含めないため、OSV-Scannerの取り込みの解釈と本サーバーの解析がずれても、範囲外のファイルは読まれません。`pom.xml` の親POMの連鎖が `OSV_MCP_ALLOWED_ROOT` の外を参照する場合は、その `pom.xml` をスキャン対象から外します([親POMの扱い](#親pomの扱い))
 - **DoS対策**: タイムアウト・stdout上限・stderr抜粋上限を設定。スキャン結果は防御的にパースし、形式不正でも例外を投げません。同時実行スキャン数も上限(デフォルト2)を設け、並列リクエストによるプロセスの無制限起動を防ぎます
 - **fail-closedな運用モード**: `OSV_MCP_REQUIRE_ALLOWED_ROOT=1` で、スキャン許可ルート未設定時にサーバーの起動自体を拒否できます
 - **通信先の固定と明示**: osv-scannerの依存解決先は `deps.dev` を明示指定し、スキャン対象のpom.xmlが指定する任意のリポジトリへ接続するモード(`--data-source native`)は使いません(テストで保証)。通信先の一覧と、deps.devへの送信を止める `OSV_MCP_NO_REMOTE_RESOLUTION=1` は[通信先とプライバシー](#通信先とプライバシー)を参照
@@ -378,6 +453,9 @@ npm run build             # dist/ へビルド
 - [x] OSV-Scannerバイナリの自動ダウンロード(チェックサム検証付き)
 - [x] Gradle対応(lockfile方式)
 - [x] `scan_java_artifact` ツール: JAR/WAR実体スキャン(lockfileが無い・shaded/fat JARのみのプロジェクト向け)
+- [x] `scan_project` ツール: Java / JavaScript / Python / Go のlockfileをまとめてスキャン
+- [ ] `suggest_fix` のJavaScript / Go対応(semver)
+- [ ] `suggest_fix` のPython対応(PEP 440)、直接/推移的依存の区別
 
 ## ライセンス
 

package/dist/index.js

@@ -16,6 +16,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { handleExplainVulnerability } from "./tools/explainVulnerability.js";
 import { handleScanJavaProject } from "./tools/scanJavaProject.js";
+import { handleScanProject } from "./tools/scanProject.js";
 import { handleScanJavaArtifact } from "./tools/scanJavaArtifact.js";
 import { handleScanSbom } from "./tools/scanSbom.js";
 import { handleSuggestFix } from "./tools/suggestFix.js";
@@ -35,8 +36,23 @@ if (startupWarning !== null) {
 // NOTE: リリース時はpackage.jsonのversionと同じ値に更新すること
 const server = new McpServer({
     name: "osv-scanner-mcp",
-    version: "0.3.4",
+    version: "0.4.0",
 });
+server.registerTool("scan_project", {
+    title: "プロジェクトの依存の脆弱性スキャン(Java / JavaScript / Python / Go)",
+    description: "プロジェクト内のlockfile・マニフェストを検出し、依存ライブラリの既知の脆弱性(CVE/GHSA)をまとめてスキャンする。" +
+        "対応: Java(pom.xml / gradle.lockfile)、JavaScript(package-lock.json / npm-shrinkwrap.json / yarn.lock / pnpm-lock.yaml / bun.lock)、" +
+        "Python(poetry.lock / uv.lock / Pipfile.lock / pdm.lock / requirements.txt)、Go(go.mod)。" +
+        "パッケージマネージャーやビルドは実行しない。" +
+        "応答先頭のcoverageを必ず確認すること: lockfileが無いマニフェスト、バージョン未固定のrequirements行、スキャン対象から外したファイルを示す。" +
+        "coverage.complete=falseの場合は、検出0件でも安全とは判断しないこと。修正版の推奨(suggest_fix)は現在Javaのみ対応。",
+    inputSchema: {
+        project_path: z
+            .string()
+            .min(1)
+            .describe("スキャン対象のプロジェクトディレクトリ、または対応するlockfile・マニフェストの絶対パス"),
+    },
+}, async ({ project_path }) => handleScanProject({ project_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
 server.registerTool("scan_java_project", {
     title: "Javaプロジェクトの脆弱性スキャン",
     description: "Java(Maven)プロジェクトをGoogle OSV-Scannerでスキャンし、依存ライブラリの既知の脆弱性(CVE/GHSA)を深刻度順のJSONレポートで返す。" +

package/dist/osv/binaryDownloader.js

@@ -16,7 +16,11 @@ import os from "node:os";
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
 import { readResponseBytes } from "../utils/readResponseBytes.js";
-/** ピン留めするOSV-Scannerのバージョン。更新時は下のチェックサムも必ず更新すること */
+/**
+ * ピン留めするOSV-Scannerのバージョン。更新時は下のチェックサムも必ず更新すること。
+ * 範囲外の読み込みを防ぐ検証はこの版の挙動に合わせているため、更新時は
+ * docs/DESIGN_TODO.md「B5」の監査と、requirements.txt・親POMの解釈の実機確認をやり直すこと
+ */
 export const PINNED_OSV_SCANNER_VERSION = "2.4.0";
 /**
  * v2.4.0公式リリースのSHA256(osv-scanner_SHA256SUMSより転記、2026-07-04取得)。

package/dist/osv/runner.js

@@ -17,6 +17,7 @@
 import { spawn } from "node:child_process";
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
+import { isManifestFormat } from "../utils/manifestFormats.js";
 import { resolveOsvScannerBinary } from "./binaryManager.js";
 import { parseOsvScanOutput } from "./scanReport.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -59,16 +60,13 @@ export function isRemoteResolutionDisabled(options = {}) {
  */
 const FIXED_SCAN_ARGS = ["scan", "source", "--format", "json", "--data-source", "deps.dev"];
 const NO_RESOLVE_ARG = "--no-resolve";
-/** 個別に渡せるマニフェスト。ファイル名をそのまま解析形式として明示する(2.4.0で実機確認) */
-const PROJECT_MANIFEST_FORMATS = new Set(["pom.xml", "gradle.lockfile", "buildscript-gradle.lockfile"]);
-/** 検出済みマニフェストを`--lockfile <形式>:<絶対パス>`の組にする。対象外のパスは渡さない */
-export function buildProjectTargetArgs(manifestPaths) {
-    return manifestPaths.flatMap((manifestPath) => {
-        const format = path.basename(manifestPath);
-        if (!PROJECT_MANIFEST_FORMATS.has(format) || !path.isAbsolute(manifestPath)) {
-            throw new Error(`Unsupported manifest path for project scan: ${manifestPath}`);
+/** 検出済みマニフェストを`--lockfile <形式>:<絶対パス>`の組にする。許可外の形式・相対パスは渡さない */
+export function buildProjectTargetArgs(targets) {
+    return targets.flatMap((target) => {
+        if (!isManifestFormat(target.format) || !path.isAbsolute(target.path)) {
+            throw new Error(`Unsupported manifest target for project scan: ${target.format}:${target.path}`);
         }
-        return ["--lockfile", `${format}:${manifestPath}`];
+        return ["--lockfile", `${target.format}:${target.path}`];
     });
 }
 const FIXED_ARTIFACT_ARGS = [
@@ -148,14 +146,14 @@ function execOsvScanner(binaryPath, targetPaths, timeoutMs, maxOutputBytes, scan
 /**
  * 検出済みマニフェストだけをOSV-Scannerでスキャンし、整形済みレポートを返す。
  *
- * @param manifestPaths **`detectJavaProject`が検出したマニフェストの絶対パス**
+ * @param targets **検出器(detectJavaProject / detectProject)が検出したマニフェスト**
  *   (このレイヤーではスキャン範囲の検証を行わない。ディレクトリは渡さない)
  */
-export async function runOsvScan(manifestPaths, options = {}) {
-    if (manifestPaths.length === 0) {
+export async function runOsvScan(targets, options = {}) {
+    if (targets.length === 0) {
         throw new ScanToolError("no_manifest_found", "スキャン対象のマニフェストがありません");
     }
-    return parseOsvScanOutput(await runScan(manifestPaths, options, "project"));
+    return parseOsvScanOutput(await runScan(buildProjectTargetArgs(targets), options, "project"));
 }
 /** Accept only the exact absolute files enumerated by detectJavaArtifacts. */
 export async function runOsvArtifactScan(artifactPaths, options = {}) {
@@ -168,24 +166,25 @@ export async function runOsvArtifactScan(artifactPaths, options = {}) {
 export async function runOsvSbomScan(snapshotPath, options = {}) {
     return runScan([snapshotPath], options, "sbom");
 }
-async function runScan(targetPaths, options, mode) {
+/** targetArgs: projectモードは`--lockfile`の組、artifact/sbomモードは検証済みの絶対パス */
+async function runScan(targetArgs, options, mode) {
     const limit = options.maxConcurrentScans ?? maxConcurrentScansFromEnv();
     if (activeScans >= limit) {
         throw new ScanToolError("too_many_concurrent_scans", `同時実行できるスキャンは${limit}件までです(現在${activeScans}件実行中)。実行中のスキャン完了後に再試行してください`);
     }
     activeScans++;
     try {
-        return await runOsvScanUnguarded(targetPaths, options, mode);
+        return await runOsvScanUnguarded(targetArgs, options, mode);
     }
     finally {
         activeScans--;
     }
 }
-async function runOsvScanUnguarded(targetPaths, options, mode) {
+async function runOsvScanUnguarded(targetArgs, options, mode) {
     const binaryPath = options.binaryPath ?? (await resolveOsvScannerBinary());
-    const result = await execOsvScanner(binaryPath, mode === "project" ? buildProjectTargetArgs(targetPaths) : targetPaths, options.timeoutMs ?? DEFAULT_TIMEOUT_MS, options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES, buildOsvScanArgs(mode, isRemoteResolutionDisabled(options)));
+    const result = await execOsvScanner(binaryPath, targetArgs, options.timeoutMs ?? DEFAULT_TIMEOUT_MS, options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES, buildOsvScanArgs(mode, isRemoteResolutionDisabled(options)));
     if (result.exitCode === EXIT_NO_PACKAGES && mode === "project") {
-        throw new ScanToolError("no_packages_found", `OSV-Scannerがスキャン対象のパッケージを検出できませんでした(マニフェスト${targetPaths.length}件。pom.xmlに依存関係が定義されているか確認してください)`, result.stderr);
+        throw new ScanToolError("no_packages_found", "OSV-Scannerがスキャン対象のパッケージを検出できませんでした(マニフェストに依存関係が定義されているか確認してください)", result.stderr);
     }
     if (mode !== "project" && result.exitCode === EXIT_NO_PACKAGES && result.stdout.trim() === "") {
         return { results: [] };

package/dist/osv/scanReport.js

@@ -119,9 +119,11 @@ export function parseOsvScanOutput(raw) {
             const key = `${ecosystem}:${name}@${version}`;
             let entry = packageMap.get(key);
             if (!entry) {
-                entry = { name, version, ecosystem, vulns: new Map() };
+                entry = { name, version, ecosystem, groups: new Set(), vulns: new Map() };
                 packageMap.set(key, entry);
             }
+            for (const group of asStrings(pkgObj.dependency_groups))
+                entry.groups.add(group);
             const details = asArray(pkgObj.vulnerabilities);
             for (const groupRaw of asArray(pkgObj.groups)) {
                 const group = asRecord(groupRaw);
@@ -171,7 +173,13 @@ function buildReport(sourceFiles, packageMap) {
             severityBreakdown[vuln.severity]++;
             vulnerabilityCount++;
         }
-        return { name: entry.name, version: entry.version, ecosystem: entry.ecosystem, vulnerabilities };
+        return {
+            name: entry.name,
+            version: entry.version,
+            ecosystem: entry.ecosystem,
+            ...(entry.groups.size > 0 ? { dependency_groups: [...entry.groups].sort() } : {}),
+            vulnerabilities,
+        };
     })
         .sort((a, b) => maxScore(b.vulnerabilities) - maxScore(a.vulnerabilities) || cmpId(a.name, b.name));
     return {

package/dist/tools/scanJavaProject.js

@@ -3,6 +3,7 @@
  * レスポンス形式(成功/エラー)は`toolResult.ts`参照。
  */
 import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
+import { sanitizeExternalText } from "../utils/externalText.js";
 import { detectJavaProject } from "../utils/projectDetector.js";
 import { errorResult, jsonResult } from "./toolResult.js";
 const TRANSITIVE_OMITTED_WARNING = "OSV_MCP_NO_REMOTE_RESOLUTIONの設定により、マニフェスト(pom.xml)からの推移的依存の解決を省略しています。" +
@@ -10,24 +11,38 @@ const TRANSITIVE_OMITTED_WARNING = "OSV_MCP_NO_REMOTE_RESOLUTIONの設定によ
     "検出0件でも推移的依存の安全性は確認できていません";
 /**
  * 推移的依存の解決状態。無効時に「検出0件」を安全と誤読されないよう応答の先頭付近に置く。
- * マニフェスト一覧の探索深さはosv-scannerの`-r`と一致しないため、一覧からpom.xmlの有無を
- * 判定せず、無効時は条件付きの警告を常に返す。
+ * 無効時は、どのマニフェストを含むかに依らず条件付きの警告を常に返す。
  */
-export function dependencyResolution(noRemoteResolution) {
+export function dependencyResolution(noRemoteResolution, warning = TRANSITIVE_OMITTED_WARNING) {
     return noRemoteResolution
-        ? { transitive_resolution: "disabled", warning: TRANSITIVE_OMITTED_WARNING }
+        ? { transitive_resolution: "disabled", warning }
         : { transitive_resolution: "enabled" };
 }
+const SKIPPED_MANIFESTS_WARNING = "一部のマニフェストをスキャン対象から外しました(skipped_manifestsを参照)。" +
+    "それらの依存の脆弱性は結果に含まれないため、検出0件でも安全とは判断しないでください";
+/**
+ * 親POMが許可ルートの外を参照するため外したマニフェスト。外したものが無ければ何も出力しない
+ * (既存の出力を変えない)。件数より前に置き、検出0件を安全と誤読させない
+ */
+export function skippedManifestsFields(skipped) {
+    if (skipped.length === 0)
+        return {};
+    return {
+        skipped_manifests: skipped.map((s) => ({ path: sanitizeExternalText(s.path), reason: sanitizeExternalText(s.reason) })),
+        scope_warning: SKIPPED_MANIFESTS_WARNING,
+    };
+}
 export async function handleScanJavaProject(args, options = {}) {
     try {
         const project = await detectJavaProject(args.project_path, {
             allowedRoot: options.allowedRoot,
         });
         const noRemoteResolution = isRemoteResolutionDisabled(options);
-        const report = await runOsvScan(project.manifestPaths, { ...options, noRemoteResolution });
+        const report = await runOsvScan(project.targets, { ...options, noRemoteResolution });
         return jsonResult({
             project_dir: project.projectDir,
             manifests: project.manifests,
+            ...skippedManifestsFields(project.skipped),
             dependency_resolution: dependencyResolution(noRemoteResolution),
             ...report,
         });

package/dist/tools/scanProject.js

@@ -0,0 +1,129 @@
+/**
+ * `scan_project`ツールのハンドラ: Java / JavaScript / Python / Goのlockfileをまとめてスキャンする。
+ *
+ * 誤要約対策(JAR実体スキャンと同じ原則): スキャンできなかった依存を示すcoverageを件数より前に置き、
+ * complete=falseの場合は「検出0件でも安全とは言えない」旨の警告を付ける。
+ */
+import { mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
+import { parseOsvScanOutput } from "../osv/scanReport.js";
+import { sanitizeExternalText } from "../utils/externalText.js";
+import { detectProject } from "../utils/manifestDetector.js";
+import { normalizePypiName } from "../utils/requirementsFile.js";
+import { dependencyResolution } from "./scanJavaProject.js";
+import { errorResult, jsonResult } from "./toolResult.js";
+const TRANSITIVE_OMITTED_WARNING = "OSV_MCP_NO_REMOTE_RESOLUTIONの設定により、マニフェスト(pom.xml / requirements.txt)からの推移的依存の解決を省略しています。" +
+    "lockfile(package-lock.json / poetry.lock / go.mod / gradle.lockfile等)に記録された依存は対象ですが、" +
+    "pom.xml・requirements.txtに直接記載された依存の先にある推移的依存の脆弱性は含まれません。" +
+    "検出0件でも推移的依存の安全性は確認できていません";
+const INCOMPLETE_WARNING = "一部の依存はスキャンされていないか、版を推測してスキャンしています" +
+    "(lockfile_missing / unpinned_requirements / unscannable_requirements / skipped_filesを参照)。" +
+    "検出0件でも、それらの依存の安全性は確認できていません";
+/** coverageの各一覧の上限(巨大なrequirements.txtで応答を膨らませない) */
+const MAX_COVERAGE_ITEMS = 200;
+function capped(items) {
+    return { items: items.slice(0, MAX_COVERAGE_ITEMS), omitted: Math.max(0, items.length - MAX_COVERAGE_ITEMS) };
+}
+function buildCoverage(project) {
+    const rel = (file) => sanitizeExternalText(path.relative(project.projectDir, file));
+    const lockfileMissing = capped(project.lockfileMissing);
+    const unpinned = capped(project.requirementIssues);
+    const unscannable = capped(project.requirementReferences);
+    const skipped = capped(project.skippedFiles);
+    const complete = project.lockfileMissing.length === 0 &&
+        project.requirementIssues.length === 0 &&
+        project.requirementReferences.length === 0 &&
+        project.skippedFiles.length === 0;
+    const omitted = lockfileMissing.omitted + unpinned.omitted + unscannable.omitted + skipped.omitted;
+    return {
+        complete,
+        ...(complete ? {} : { warning: INCOMPLETE_WARNING }),
+        manifests: project.manifests.map((m) => ({ path: sanitizeExternalText(m.path), ecosystem: m.ecosystem, format: m.format })),
+        lockfile_missing: lockfileMissing.items.map((m) => ({
+            path: sanitizeExternalText(m.path),
+            ecosystem: m.ecosystem,
+            status: m.status,
+            hint: sanitizeExternalText(m.hint),
+        })),
+        unpinned_requirements: unpinned.items.map((issue) => ({
+            file: rel(issue.file),
+            line: issue.line,
+            name: sanitizeExternalText(issue.name),
+            specifier: sanitizeExternalText(issue.specifier),
+            kind: issue.kind,
+        })),
+        unscannable_requirements: unscannable.items.map((ref) => ({
+            file: rel(ref.file),
+            line: ref.line,
+            text: sanitizeExternalText(ref.text),
+            reason: ref.reason,
+        })),
+        skipped_files: skipped.items.map((s) => ({ path: sanitizeExternalText(s.path), reason: sanitizeExternalText(s.reason) })),
+        ...(omitted > 0 ? { omitted_items: omitted } : {}),
+    };
+}
+function ecosystemBreakdown(project, packages) {
+    const breakdown = {};
+    for (const manifest of project.manifests) {
+        breakdown[manifest.ecosystem] ??= { manifests: 0, vulnerable_package_count: 0, vulnerability_count: 0 };
+        breakdown[manifest.ecosystem].manifests++;
+    }
+    for (const pkg of packages) {
+        breakdown[pkg.ecosystem] ??= { manifests: 0, vulnerable_package_count: 0, vulnerability_count: 0 };
+        breakdown[pkg.ecosystem].vulnerable_package_count++;
+        breakdown[pkg.ecosystem].vulnerability_count += pkg.vulnerabilities.length;
+    }
+    return breakdown;
+}
+/** `>=X` / `~=X` の行は、osv-scannerが下限Xを使用中の版とみなしてスキャンしている */
+function markLowerBounds(project, packages) {
+    return packages.map((pkg) => pkg.ecosystem === "PyPI" &&
+        project.lowerBounds.some((lb) => lb.name === normalizePypiName(pkg.name) && lb.version === pkg.version)
+        ? { ...pkg, version_is_lower_bound: true }
+        : pkg);
+}
+/**
+ * requirements.txtは検証済みの正規化行だけを専用の一時ディレクトリに書いてスキャンする
+ * (元ファイルの取り込み指定をosv-scannerにたどらせない)。成功・失敗とも削除する。
+ */
+async function scanWithRequirementsCopies(project, options) {
+    const copies = project.requirementsCopies.filter((copy) => copy.entries.length > 0);
+    if (project.targets.length === 0 && copies.length === 0)
+        return parseOsvScanOutput({ results: [] });
+    const dir = copies.length > 0 ? await mkdtemp(path.join(await realpath(os.tmpdir()), "osv-mcp-req-")) : null;
+    try {
+        const targets = [...project.targets];
+        for (const [index, copy] of copies.entries()) {
+            const copyPath = path.join(dir, `${index}.txt`);
+            await writeFile(copyPath, `${copy.entries.join("\n")}\n`, { mode: 0o600, flag: "wx" });
+            targets.push({ path: copyPath, format: "requirements.txt" });
+        }
+        return await runOsvScan(targets, options);
+    }
+    finally {
+        if (dir !== null)
+            await rm(dir, { recursive: true, force: true });
+    }
+}
+export async function handleScanProject(args, options = {}) {
+    try {
+        const project = await detectProject(args.project_path, { allowedRoot: options.allowedRoot });
+        const noRemoteResolution = isRemoteResolutionDisabled(options);
+        const report = await scanWithRequirementsCopies(project, { ...options, noRemoteResolution });
+        return jsonResult({
+            project_dir: project.projectDir,
+            dependency_resolution: dependencyResolution(noRemoteResolution, TRANSITIVE_OMITTED_WARNING),
+            coverage: buildCoverage(project),
+            ecosystem_breakdown: ecosystemBreakdown(project, report.packages),
+            vulnerable_package_count: report.vulnerable_package_count,
+            vulnerability_count: report.vulnerability_count,
+            severity_breakdown: report.severity_breakdown,
+            packages: markLowerBounds(project, report.packages),
+        });
+    }
+    catch (error) {
+        return errorResult(error);
+    }
+}

package/dist/tools/suggestFix.js

@@ -6,7 +6,7 @@
 import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
 import { suggestUpgrades } from "../osv/suggestFix.js";
 import { detectJavaProject } from "../utils/projectDetector.js";
-import { dependencyResolution, } from "./scanJavaProject.js";
+import { dependencyResolution, skippedManifestsFields, } from "./scanJavaProject.js";
 import { errorResult, jsonResult } from "./toolResult.js";
 export async function handleSuggestFix(args, options = {}) {
     try {
@@ -14,12 +14,13 @@ export async function handleSuggestFix(args, options = {}) {
             allowedRoot: options.allowedRoot,
         });
         const noRemoteResolution = isRemoteResolutionDisabled(options);
-        const report = await runOsvScan(project.manifestPaths, { ...options, noRemoteResolution });
+        const report = await runOsvScan(project.targets, { ...options, noRemoteResolution });
         const suggestions = suggestUpgrades(report.packages);
         const unfixedVulnerabilities = suggestions.reduce((sum, s) => sum + s.per_cve_detail.filter((d) => d.tier === "unfixed").length, 0);
         return jsonResult({
             project_dir: project.projectDir,
             manifests: project.manifests,
+            ...skippedManifestsFields(project.skipped),
             dependency_resolution: dependencyResolution(noRemoteResolution),
             vulnerable_package_count: suggestions.length,
             unfixed_vulnerability_count: unfixedVulnerabilities,