osv-scanner-mcp 0.4.0 → 0.4.2

package/README.md

@@ -16,7 +16,7 @@ Google製 [OSV-Scanner](https://github.com/google/osv-scanner) をラップす
 - **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)とサマリ集計付きで返します
-- **修正版の提示**: 各脆弱性の `fixed_versions` をMavenバージョン優先順位規則で正しくソートして含めます(`2.17.1-RELEASE` のようなsemver非対応の表記にも対応)
+- **修正版の提示**: 各脆弱性の `fixed_versions` を含めます。MavenはMavenバージョン優先順位規則(`2.17.1-RELEASE` のようなsemver非対応の表記にも対応)、npm・GoはSemantic Versioningの優先順位で正しくソートします
 - **セキュリティ第一の設計**: シェル非経由の実行・引数ホワイトリスト・パス正規化と境界チェック・タイムアウト/出力サイズ上限を実装段階から組み込んでいます
 
 ## 動作要件
@@ -119,7 +119,7 @@ npm run build
 | 変数 | 説明 |
 |---|---|
 | `OSV_SCANNER_PATH` | 使用するosv-scannerバイナリの明示指定。省略時はPATH→自動ダウンロードの順で解決。**指定が無効な場合はフォールバックせずエラーになります**(意図しないバイナリの実行防止) |
-| `OSV_MCP_ALLOWED_ROOT` | 指定時、このディレクトリ配下以外のスキャンを拒否します(パストラバーサル対策の境界)。**設定を推奨** |
+| `OSV_MCP_ALLOWED_ROOT` | 指定時、このディレクトリ配下以外のスキャンを拒否します(パストラバーサル対策の境界)。**設定を推奨**。空文字・空白のみは未設定として扱います |
 | `OSV_MCP_REQUIRE_ALLOWED_ROOT` | `1` または `true` 指定時、`OSV_MCP_ALLOWED_ROOT` が未設定ならサーバーの起動自体を拒否します(運用環境向けのfail-closedモード) |
 | `OSV_MCP_MAX_CONCURRENT_SCANS` | 同時実行できるスキャン数の上限(デフォルト `2`、最大 `16`)。超過したリクエストは待たずに即時エラーになります |
 | `OSV_MCP_AUTO_DOWNLOAD` | `0` または `false` でバイナリの自動ダウンロードを無効化(デフォルト有効) |
@@ -208,7 +208,7 @@ api.osv.dev と deps.dev はどちらも Google が運営するサービスで
   - `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の扱い)を参照)
+  - `skipped_files`: スキャン対象から外したファイルと理由(requirements.txt自体が読めない・1MiBを超える場合、`pom.xml` の親POMが許可ルートの外を参照する場合)。親POMを読めず、親POMを含めずにスキャンした `pom.xml` もここに理由付きで示します([親POMの扱い](#親pomの扱い)を参照)
   - 各一覧は200件までで、超えた分の件数を `omitted_items` に返します
 - `ecosystem_breakdown` は、脆弱性0件のエコシステムも含めて「スキャンした」ことを示します
 - `dependency_groups` はOSV-Scannerが付けた依存グループ(例: `dev`)の生の値です。lockfileの形式によって欠落・不正確なため(pnpmでは付かず、pdmでは `optional` になる等)、参考情報として扱ってください
@@ -234,6 +234,8 @@ OSV-Scannerは `pom.xml` の `<parent>` が参照する親POM(`<relativePath>`
 
 `OSV_MCP_ALLOWED_ROOT` を設定している場合、親POMの連鎖のどこかが**許可ルートの外**のファイルを参照する `pom.xml` は、スキャン対象から外します(許可ルート外のファイルの内容を結果や照会先に出さないため)。外したファイルは応答の `skipped_manifests`(`scan_project` では `coverage.skipped_files`)に理由付きで示し、`scope_warning` で「検出0件でも安全とは判断しない」旨を伝えます。全件が外れた場合や、該当する `pom.xml` を直接指定した場合は `path_outside_allowed_root` を返します。
 
+存在する親POMを読めない場合(10MiBを超える、名前付きパイプ等の通常のファイルでない、末尾がシンボリックリンク等)は、その `pom.xml` を親POMを含めずにスキャンし、親から継承する依存が欠ける可能性を応答の `incomplete_manifests`(`scan_project` では `coverage.skipped_files`、`coverage.complete` は `false`)に理由付きで示します。子の `pom.xml` に依存が無く `no_packages_found` になる場合も、エラーのメッセージに同じ理由を含めます。親POMが存在しない場合(ルートの `pom.xml` で既定の `../pom.xml` が無い等)は、元の配置でもOSV-Scannerは親を読まないため欠落として扱いません。
+
 - 許可ルート内の親POMは従来どおり読みます(サブモジュールのスキャンは許可ルート内なら引き続き使えます)
 - `<relativePath/>`(空)はローカルの親POMを参照しないため対象外です
 - 親POMの指定は、OSV-Scanner(Go)のXMLの解釈に合わせて読みます。要素は名前空間の接頭辞に関係なく要素名で照合し(`<m:parent>` も親として扱う)、ルート要素の直下の `parent` だけを対象にし、文字参照を展開します
@@ -275,7 +277,7 @@ OSV-Scannerは `pom.xml` の `<parent>` が参照する親POM(`<relativePath>`
 ```
 
 - `packages` は最も深刻な脆弱性を持つ順、各 `vulnerabilities` は深刻度順(unknownは末尾)
-- `fixed_versions` はMaven優先順位で昇順。複数のリリース系統(例: 2.12系バックポートと2.15系)が混在することがあります。空配列は「修正版が存在しない」ことを意味します
+- `fixed_versions` はOSVに記載された修正版です。MavenはMaven優先順位、npm・GoはSemantic Versioningの優先順位で昇順(SemVerとして解釈できない表記は末尾)、PyPI等はOSVの記載順のまま(並び順は保証しません)。複数のリリース系統(例: 2.12系バックポートと2.15系)が混在することがあります。プレリリース版(`5.0.0-beta.3`)やGoの疑似バージョン(`0.0.0-20180925071336-cf3bd585ca2a`)が含まれることもあります。空配列は「OSVに修正版の記載がない」ことを意味します。v0.4.1以前はMaven以外のパッケージで常に空配列を返していました
 - `severity_score` が取得できない脆弱性は `null` / `"unknown"` として扱います
 
 ### `scan_java_artifact`
@@ -371,7 +373,7 @@ OSV-Scanner 2.4.0の `java/archive` プラグインを使用し、ネストJAR
 - MavenのOSV `ECOSYSTEM` 範囲(`introduced` / `fixed` / `last_affected` / 上限なし)を照合します。`versions` に明示された影響も確認します。範囲欠落・不正・未対応形式・`limit` による不完全な情報では安全と推定せず、候補を検証できなければ `recommended_upgrade: null`、`verification: "no_verified_candidate"` を返します。
 - 推奨時は `verification: "verified"`、CVEごとの `recommended_status` は `affected` / `not_affected` / `unknown` です。推奨保留時は `not_evaluated` になります。`per_cve_detail.fixed_in` は各CVE単独の候補であり、最終推奨先の判定は `recommended_status` を参照してください。
 - 現在より新しい修正版候補がないCVEは `tier: "unfixed"` として推奨の修正対象から除外します(情報欠落を含む場合があります)。除外したCVEも推奨先で判定し、その状態を表示します。全CVEがunfixedの場合も `recommended_upgrade` は `null` です。
-- 修正版の推奨はMavenのみ対応です。Maven以外のパッケージは `verification: "unsupported_ecosystem"`、CVEごとの `tier: "unsupported"` を返し、`unfixed` には数えません(修正版の有無は判定していないため。修正版は `explain_vulnerability` で確認できます)。
+- 修正版の推奨はMavenのみ対応です。Maven以外のパッケージは `verification: "unsupported_ecosystem"`、CVEごとの `tier: "unsupported"` を返し、`unfixed` には数えません(修正版の有無は判定していないため。修正版は `scan_project` の `fixed_versions` や `explain_vulnerability` で確認できます)。
 
 ### `explain_vulnerability`
 
@@ -405,6 +407,7 @@ OSV-Scanner 2.4.0の `java/archive` プラグインを使用し、ネストJAR
 | `binary_not_found` | OSV-Scannerが見つからない(インストール案内をmessageに含む) |
 | `project_not_found` | 指定パスが存在しない・ディレクトリ/pom.xmlでない |
 | `no_manifest_found` | 対応マニフェスト(pom.xml / gradle.lockfile)が見つからない |
+| `scan_input_too_large` | スキャン対象ファイル(一時ディレクトリへのコピー)の合計サイズが上限(2GiB)を超えた。対象を絞って再実行する |
 | `manifest_search_limit_exceeded` | マニフェスト探索が上限(20万エントリ・1,000マニフェスト)に達した。より狭いディレクトリかマニフェストを直接指定する |
 | `binary_download_failed` | バイナリのダウンロード失敗(未対応プラットフォーム含む) |
 | `binary_checksum_mismatch` | ダウンロードしたバイナリのチェックサム不一致(改ざん/破損の可能性) |
@@ -427,8 +430,9 @@ OSV-Scanner 2.4.0の `java/archive` プラグインを使用し、ネストJAR
 
 - **サプライチェーン対策**: バイナリの自動ダウンロードは公式GitHub Releasesに限定し、バージョンをピン留め。**パッケージに埋め込まれたSHA256チェックサム**で検証します(配布元のSHA256SUMSファイルは信用しないため、リリース側が改ざんされても検出可能)。検証合格まで実行権限を与えず、キャッシュ済みバイナリも使用のたびに再検証します。`OSV_MCP_PREFER_DOWNLOAD=1` でPATH上の未検証バイナリを使わない運用も選べます
 - **コマンドインジェクション対策**: シェルを経由しない `spawn` + 引数配列で実行。OSV-Scannerへの引数は固定リストのみで、可変部は検証済み絶対パス1つだけ
+- **スナップショット方式(検査と読み込みの不一致の防止)**: OSV-Scannerには元のファイルを一切渡しません。lockfile・`pom.xml`(親POMの連鎖を含む)・JAR/WARは、本サーバーが安全に1回だけ読んだ内容を専用の一時ディレクトリ(所有者のみアクセス可、終了時に削除)へコピーしてスキャンし、検査もそのコピーに対して行います。検査の後で元のファイルやディレクトリを差し替えても結果には影響しません。親POMは元の配置を一時ディレクトリ内に再現してコピーするため、OSV-Scannerが相対パスで親をたどっても、見つかるのは検証してコピーしたファイルだけです(`..` を重ねて一時ディレクトリの外に届く参照は除外)。読み込みは末尾のシンボリックリンクをたどらず、名前付きパイプ等の通常のファイル以外は読まず(処理が止まらない)、読み終えた後にパスを解決し直して境界の内側かつ開いた実体と同じファイルかを確認します。コピーの合計サイズは2GiBまでです(超えると `scan_input_too_large`)
 - **パストラバーサル対策**: 入力パスは `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)を設け、並列リクエストによるプロセスの無制限起動を防ぎます
+- **DoS対策**: タイムアウト・stdout上限・stderr抜粋上限を設定。スキャン結果は防御的にパースし、形式不正でも例外を投げません。同時実行スキャン数も上限(デフォルト2)を設け、並列リクエストによるプロセスの無制限起動を防ぎます。本サーバー自身の解析も、同じファイルは1回だけ読んで結果を使い回し(workspaceの収録確認でのlockfile、requirements.txtの共通の取り込み先、親POM)、読む量の合計に上限を設けます
 - **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` は[通信先とプライバシー](#通信先とプライバシー)を参照
 - **情報漏えい対策**: 想定外の例外はスタックトレース等を含めず `internal_error` に丸めます。外部由来のテキスト(脆弱性summary等)は長さ上限付きの「データ」として構造化して返します

package/dist/index.js

@@ -20,7 +20,7 @@ import { handleScanProject } from "./tools/scanProject.js";
 import { handleScanJavaArtifact } from "./tools/scanJavaArtifact.js";
 import { handleScanSbom } from "./tools/scanSbom.js";
 import { handleSuggestFix } from "./tools/suggestFix.js";
-import { ALLOWED_ROOT_ENV, allowedRootStartupError, allowedRootStartupWarning, } from "./utils/startupConfig.js";
+import { ALLOWED_ROOT_ENV, allowedRootFromEnv, allowedRootStartupError, allowedRootStartupWarning, } from "./utils/startupConfig.js";
 export { ALLOWED_ROOT_ENV };
 // fail-closed: 運用モードで許可ルートが未設定なら、ツールを一切公開せず終了する
 const startupError = allowedRootStartupError();
@@ -36,7 +36,7 @@ if (startupWarning !== null) {
 // NOTE: リリース時はpackage.jsonのversionと同じ値に更新すること
 const server = new McpServer({
     name: "osv-scanner-mcp",
-    version: "0.4.0",
+    version: "0.4.2",
 });
 server.registerTool("scan_project", {
     title: "プロジェクトの依存の脆弱性スキャン(Java / JavaScript / Python / Go)",
@@ -52,7 +52,7 @@ server.registerTool("scan_project", {
             .min(1)
             .describe("スキャン対象のプロジェクトディレクトリ、または対応するlockfile・マニフェストの絶対パス"),
     },
-}, async ({ project_path }) => handleScanProject({ project_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
+}, async ({ project_path }) => handleScanProject({ project_path }, { allowedRoot: allowedRootFromEnv() }));
 server.registerTool("scan_java_project", {
     title: "Javaプロジェクトの脆弱性スキャン",
     description: "Java(Maven)プロジェクトをGoogle OSV-Scannerでスキャンし、依存ライブラリの既知の脆弱性(CVE/GHSA)を深刻度順のJSONレポートで返す。" +
@@ -65,7 +65,7 @@ server.registerTool("scan_java_project", {
             .min(1)
             .describe("スキャン対象のプロジェクトディレクトリ、またはpom.xml/gradle.lockfileの絶対パス"),
     },
-}, async ({ project_path }) => handleScanJavaProject({ project_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
+}, async ({ project_path }) => handleScanJavaProject({ project_path }, { allowedRoot: allowedRootFromEnv() }));
 server.registerTool("suggest_fix", {
     title: "脆弱性を解消する推奨アップグレードの提案",
     description: "Java(Maven)プロジェクトをスキャンし、脆弱な依存パッケージごとに推奨アップグレードバージョンを提案する。" +
@@ -81,7 +81,7 @@ server.registerTool("suggest_fix", {
             .min(1)
             .describe("スキャン対象のプロジェクトディレクトリ、またはpom.xml/gradle.lockfileの絶対パス"),
     },
-}, async ({ project_path }) => handleSuggestFix({ project_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
+}, async ({ project_path }) => handleSuggestFix({ project_path }, { allowedRoot: allowedRootFromEnv() }));
 server.registerTool("explain_vulnerability", {
     title: "脆弱性の詳細説明の取得",
     description: "指定したGHSA-IDまたはCVE-IDの脆弱性の詳細をOSVデータベース(api.osv.dev)から取得して返す。" +
@@ -103,7 +103,7 @@ server.registerTool("scan_java_artifact", {
     inputSchema: {
         artifact_path: z.string().min(1).describe("JAR/WARファイル、または探索するディレクトリの絶対パス"),
     },
-}, async ({ artifact_path }) => handleScanJavaArtifact({ artifact_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
+}, async ({ artifact_path }) => handleScanJavaArtifact({ artifact_path }, { allowedRoot: allowedRootFromEnv() }));
 server.registerTool("scan_sbom", {
     title: "SBOMの脆弱性スキャン",
     description: "CycloneDX 1.4/1.5/1.6またはSPDX 2.2/2.3のJSON SBOMから識別できる依存をスキャンする。" +
@@ -112,7 +112,7 @@ server.registerTool("scan_sbom", {
     inputSchema: {
         sbom_path: z.string().min(1).describe("CycloneDX/SPDX JSON SBOMファイルの絶対パス"),
     },
-}, async ({ sbom_path }) => handleScanSbom({ sbom_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
+}, async ({ sbom_path }) => handleScanSbom({ sbom_path }, { allowedRoot: allowedRootFromEnv() }));
 const transport = new StdioServerTransport();
 await server.connect(transport);
 // stdoutはMCPプロトコル専用のため、起動ログはstderrへ

package/dist/osv/scanReport.js

@@ -12,9 +12,9 @@
  * OSV-Scannerの出力は外部由来データなので、形式が想定と異なっても例外を投げず
  * 読み取れた範囲でレポートを構築する(欠損フィールドはスキップ)。
  */
-import { compareMavenVersions } from "../utils/mavenVersion.js";
 import { asArray, asRecord, asString, asStrings } from "../utils/unknownJson.js";
 import { extractAffectedVersions } from "./affectedVersions.js";
+import { sortVersions, versionRangeTypes } from "./versionScheme.js";
 /** 外部由来のsummaryをLLMに渡す際の長さ上限(プロンプト肥大・DoS対策) */
 const MAX_SUMMARY_LENGTH = 500;
 const CVSS_CRITICAL = 9.0;
@@ -65,9 +65,12 @@ function extractSummary(vulnDetails) {
 /**
  * OSVエントリの`affected[].ranges[].events[].fixed`から修正版を収集する。
  * 1つのOSVエントリが複数パッケージをカバーしうるため、対象パッケージ名で絞り込む。
+ * 範囲の型はエコシステム別(versionScheme.ts)。GIT型のコミットハッシュは集めない。
+ * v0.4.1以前はMavenだけを集めていたため、npm・Go・PyPI等で常に空になっていた。
  */
 function extractFixedVersions(vulnDetails, packageName, ecosystem) {
     const versions = new Set();
+    const rangeTypes = versionRangeTypes(ecosystem);
     for (const detail of vulnDetails) {
         for (const affectedRaw of asArray(detail.affected)) {
             const affected = asRecord(affectedRaw);
@@ -77,7 +80,8 @@ function extractFixedVersions(vulnDetails, packageName, ecosystem) {
             if (affectedName !== packageName || asString(asRecord(affected.package)?.ecosystem) !== ecosystem)
                 continue;
             for (const rangeRaw of asArray(affected.ranges)) {
-                if (asRecord(rangeRaw)?.type !== "ECOSYSTEM" || ecosystem !== "Maven")
+                const type = asString(asRecord(rangeRaw)?.type);
+                if (type === null || !rangeTypes.has(type))
                     continue;
                 for (const eventRaw of asArray(asRecord(rangeRaw)?.events)) {
                     const fixed = asString(asRecord(eventRaw)?.fixed);
@@ -87,7 +91,7 @@ function extractFixedVersions(vulnDetails, packageName, ecosystem) {
             }
         }
     }
-    return [...versions].sort(compareMavenVersions);
+    return sortVersions(versions, ecosystem);
 }
 /**
  * OSV-Scannerの`--format json`出力を`scan_java_project`のレポートに変換する。

package/dist/osv/versionScheme.js

@@ -0,0 +1,39 @@
+/**
+ * エコシステムごとのバージョンの扱い(docs/DESIGN_TODO.md「suggest_fix npm/Go対応」)。
+ *
+ * - Maven: Mavenの優先順位(mavenVersion.ts)。範囲はECOSYSTEM型
+ * - npm・Go: SemVer 2.0.0の優先順位(semverVersion.ts)。範囲はSEMVER型とECOSYSTEM型
+ * - その他(PyPI等): 比較器なし。範囲はECOSYSTEM型
+ *
+ * GIT型の範囲(コミットハッシュ)はリリース版と無関係のため、どのエコシステムでも版として扱わない。
+ */
+import { compareMavenVersions } from "../utils/mavenVersion.js";
+import { compareParsedSemver, parseSemver } from "../utils/semverVersion.js";
+const SEMVER_ECOSYSTEMS = new Set(["npm", "Go"]);
+/** 修正版・影響範囲として読み取るOSVの範囲の型 */
+export function versionRangeTypes(ecosystem) {
+    if (ecosystem === "Maven")
+        return new Set(["ECOSYSTEM"]);
+    if (SEMVER_ECOSYSTEMS.has(ecosystem))
+        return new Set(["SEMVER", "ECOSYSTEM"]);
+    return new Set(["ECOSYSTEM"]);
+}
+/**
+ * 重複を除いた版の一覧を、エコシステムの優先順位で昇順に並べる。
+ * - npm・Go: SemVerとして解釈できない版は末尾に記載順のまま置く
+ * - 比較器のないエコシステム: 記載順のまま返す
+ */
+export function sortVersions(versions, ecosystem) {
+    const unique = [...new Set(versions)];
+    if (ecosystem === "Maven")
+        return unique.sort(compareMavenVersions);
+    if (!SEMVER_ECOSYSTEMS.has(ecosystem))
+        return unique;
+    const parsed = unique.flatMap((raw) => {
+        const version = parseSemver(raw);
+        return version === null ? [] : [{ raw, version }];
+    });
+    const unparsed = unique.filter((raw) => parseSemver(raw) === null);
+    parsed.sort((a, b) => compareParsedSemver(a.version, b.version) || (a.raw < b.raw ? -1 : a.raw > b.raw ? 1 : 0));
+    return [...parsed.map((p) => p.raw), ...unparsed];
+}

package/dist/tools/scanJavaArtifact.js

@@ -1,12 +1,43 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
 import { buildArtifactReport } from "../osv/artifactReport.js";
 import { runOsvArtifactScan } from "../osv/runner.js";
 import { detectJavaArtifacts } from "../utils/artifactDetector.js";
+import { ScanSnapshot } from "../utils/scanSnapshot.js";
+import { asArray, asRecord } from "../utils/unknownJson.js";
 import { errorResult, jsonResult } from "./toolResult.js";
+/** スキャナーが返したパス(スナップショットのコピー)を元のファイルに戻す */
+function restoreSourcePaths(raw, originals) {
+    for (const result of asArray(asRecord(raw)?.results)) {
+        const source = asRecord(asRecord(result)?.source);
+        if (source && typeof source.path === "string") {
+            const original = originals.get(source.path);
+            if (original !== undefined)
+                source.path = original;
+        }
+    }
+    return raw;
+}
 export async function handleScanJavaArtifact(args, options = {}) {
     try {
-        const { artifactPaths } = await detectJavaArtifacts(args.artifact_path, options);
-        const raw = await runOsvArtifactScan(artifactPaths, options);
-        return jsonResult(buildArtifactReport(raw, artifactPaths));
+        const { targetPath, artifactPaths } = await detectJavaArtifacts(args.artifact_path, options);
+        const boundary = (await stat(targetPath)).isDirectory() ? targetPath : path.dirname(targetPath);
+        // 元のJAR/WARは渡さず、安全に読んだ内容のコピーをスキャンする(検査後の差し替え対策)。
+        // コピーできなかったものはスキャンされず、同定不能として報告される
+        const snapshot = await ScanSnapshot.create();
+        try {
+            const originals = new Map();
+            for (const artifact of artifactPaths) {
+                const copy = await snapshot.copy(artifact, boundary);
+                if (copy.ok)
+                    originals.set(copy.path, artifact);
+            }
+            const raw = originals.size > 0 ? await snapshot.guard(() => runOsvArtifactScan([...originals.keys()], options)) : { results: [] };
+            return jsonResult(buildArtifactReport(restoreSourcePaths(raw, originals), artifactPaths));
+        }
+        finally {
+            await snapshot.cleanup();
+        }
     }
     catch (error) {
         return errorResult(error);

package/dist/tools/scanJavaProject.js

@@ -2,9 +2,12 @@
  * `scan_java_project`ツールのハンドラ。
  * レスポンス形式(成功/エラー)は`toolResult.ts`参照。
  */
+import path from "node:path";
+import { ScanToolError } from "../errors.js";
 import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
 import { sanitizeExternalText } from "../utils/externalText.js";
 import { detectJavaProject } from "../utils/projectDetector.js";
+import { ScanSnapshot, snapshotManifests } from "../utils/scanSnapshot.js";
 import { errorResult, jsonResult } from "./toolResult.js";
 const TRANSITIVE_OMITTED_WARNING = "OSV_MCP_NO_REMOTE_RESOLUTIONの設定により、マニフェスト(pom.xml)からの推移的依存の解決を省略しています。" +
     "lockfile(gradle.lockfile)に記録された依存は対象ですが、pom.xmlに直接記載された依存の先にある推移的依存の脆弱性は含まれません。" +
@@ -18,31 +21,82 @@ export function dependencyResolution(noRemoteResolution, warning = TRANSITIVE_OM
         ? { transitive_resolution: "disabled", warning }
         : { transitive_resolution: "enabled" };
 }
-const SKIPPED_MANIFESTS_WARNING = "一部のマニフェストをスキャン対象から外しました(skipped_manifestsを参照)。" +
+const SKIPPED_MANIFESTS_WARNING = "一部のマニフェストをスキャン対象から外したか、親POMを含めずにスキャンしました(skipped_manifests / incomplete_manifestsを参照)。" +
     "それらの依存の脆弱性は結果に含まれないため、検出0件でも安全とは判断しないでください";
 /**
- * 親POMが許可ルートの外を参照するため外したマニフェスト。外したものが無ければ何も出力しない
- * (既存の出力を変えない)。件数より前に置き、検出0件を安全と誤読させない
+ * 外したマニフェスト(skipped)と、親POMを再現できずにスキャンしたマニフェスト(incomplete)。
+ * どちらも無ければ何も出力しない(既存の出力を変えない)。件数より前に置き、検出0件を安全と誤読させない
  */
-export function skippedManifestsFields(skipped) {
-    if (skipped.length === 0)
+export function skippedManifestsFields(skipped, incomplete = []) {
+    if (skipped.length === 0 && incomplete.length === 0)
         return {};
+    const list = (items) => items.map((s) => ({ path: sanitizeExternalText(s.path), reason: sanitizeExternalText(s.reason) }));
     return {
-        skipped_manifests: skipped.map((s) => ({ path: sanitizeExternalText(s.path), reason: sanitizeExternalText(s.reason) })),
+        ...(skipped.length > 0 ? { skipped_manifests: list(skipped) } : {}),
+        ...(incomplete.length > 0 ? { incomplete_manifests: list(incomplete) } : {}),
         scope_warning: SKIPPED_MANIFESTS_WARNING,
     };
 }
+/**
+ * スキャン対象を外した・親POMを含めずにスキャンしたマニフェストがある状態で「パッケージなし」になった場合、
+ * エラーにもその旨を含める(応答の一覧が出ないため、欠落を黙って「依存なし」と読ませない)。
+ */
+export async function withScopeNotes(notes, scan) {
+    try {
+        return await scan();
+    }
+    catch (error) {
+        if (!(error instanceof ScanToolError) || error.kind !== "no_packages_found" || notes.length === 0)
+            throw error;
+        throw new ScanToolError(error.kind, `${error.message}。ただし次のマニフェストはスキャン対象から外したか、親POMを含めずにスキャンしたため、` +
+            `検出0件でも安全とは判断しないでください: ${notes.map((n) => `${n.path}: ${n.reason}`).join(" / ")}`, error.detail);
+    }
+}
+/**
+ * 検出したマニフェストをスナップショットへコピーし、コピーをスキャンする(元のファイルは渡さない)。
+ * 応答に一時ディレクトリのパスを出さないよう、スキャナーのパスは元のファイルに戻す。
+ * スナップショットは成功・失敗とも削除する。全件除外ならエラー。
+ */
+export async function scanJavaManifests(project, options) {
+    const snapshot = await ScanSnapshot.create();
+    try {
+        const { targets, skipped, incomplete } = await snapshotManifests(snapshot, project.targets, {
+            projectDir: project.projectDir,
+            allowedRootReal: project.allowedRootReal,
+        });
+        const skippedPaths = new Set(skipped.map((s) => s.path));
+        const scanned = project.targets.filter((t) => !skippedPaths.has(t.path));
+        const relative = (file) => path.relative(project.projectDir, file);
+        const skippedRelative = skipped.map((s) => ({ path: relative(s.path), reason: s.reason }));
+        if (targets.length === 0) {
+            const details = skippedRelative.map((s) => `${s.path}: ${s.reason}`).join(" / ");
+            throw new ScanToolError(skipped.every((s) => s.kind === "outside_allowed_root") ? "path_outside_allowed_root" : "no_manifest_found", `スキャンできるマニフェストがありません(${details})`);
+        }
+        const originals = new Map(targets.map((copy, i) => [copy.path, scanned[i].path]));
+        const incompleteRelative = incomplete.map((s) => ({ path: relative(s.path), reason: s.reason }));
+        const report = await withScopeNotes([...skippedRelative, ...incompleteRelative], () => snapshot.guard(() => runOsvScan(targets, options)));
+        return {
+            manifests: scanned.map((t) => relative(t.path)),
+            skipped: skippedRelative,
+            incomplete: incompleteRelative,
+            report: { ...report, source_files: report.source_files.map((file) => originals.get(file) ?? file) },
+        };
+    }
+    finally {
+        await snapshot.cleanup();
+    }
+}
 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.targets, { ...options, noRemoteResolution });
+        const { manifests, skipped, incomplete, report } = await scanJavaManifests(project, { ...options, noRemoteResolution });
         return jsonResult({
             project_dir: project.projectDir,
-            manifests: project.manifests,
-            ...skippedManifestsFields(project.skipped),
+            manifests,
+            ...skippedManifestsFields(skipped, incomplete),
             dependency_resolution: dependencyResolution(noRemoteResolution),
             ...report,
         });

package/dist/tools/scanProject.js

@@ -4,15 +4,15 @@
  * 誤要約対策(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 { ScanToolError } from "../errors.js";
 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 { ScanSnapshot, snapshotManifests } from "../utils/scanSnapshot.js";
+import { dependencyResolution, withScopeNotes } 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等)に記録された依存は対象ですが、" +
@@ -88,30 +88,46 @@ function markLowerBounds(project, packages) {
  * 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;
+/**
+ * 元のファイルはosv-scannerに渡さず、スナップショット(scanSnapshot.ts)のコピーをスキャンする。
+ * lockfile・pom.xml(親POMの連鎖を含む)は安全に読んだ内容のコピー、requirements.txtは
+ * 検証済みの正規化行だけを書いたコピー。コピーできず外したファイルはskippedFilesに記録する。
+ */
+async function scanFromSnapshot(project, options) {
+    const snapshot = await ScanSnapshot.create();
     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" });
+        const { targets, skipped, incomplete } = await snapshotManifests(snapshot, project.targets, {
+            projectDir: project.projectDir,
+            allowedRootReal: project.allowedRootReal,
+        });
+        // 親POMを再現できずにスキャンしたpom.xmlも、欠落の可能性としてcoverageに出す(complete=falseになる)
+        project.skippedFiles.push(...incomplete.map((s) => ({ path: path.relative(project.projectDir, s.path), reason: s.reason })));
+        if (skipped.length > 0) {
+            const skippedPaths = new Set(skipped.map((s) => s.path));
+            project.manifests = project.manifests.filter((m) => !skippedPaths.has(path.join(project.projectDir, m.path)));
+            project.skippedFiles.push(...skipped.map((s) => ({ path: path.relative(project.projectDir, s.path), reason: s.reason })));
+            if (project.manifests.length === 0) {
+                throw new ScanToolError(skipped.every((s) => s.kind === "outside_allowed_root") ? "path_outside_allowed_root" : "no_manifest_found", `スキャンできるlockfile・マニフェストがありません(${project.skippedFiles.map((s) => `${s.path}: ${s.reason}`).join(" / ")})`);
+            }
+        }
+        for (const copy of project.requirementsCopies) {
+            if (copy.entries.length === 0)
+                continue;
+            targets.push({ path: await snapshot.writeGenerated(`${copy.entries.join("\n")}\n`), format: "requirements.txt" });
         }
-        return await runOsvScan(targets, options);
+        if (targets.length === 0)
+            return parseOsvScanOutput({ results: [] });
+        return await withScopeNotes(project.skippedFiles, () => snapshot.guard(() => runOsvScan(targets, options)));
     }
     finally {
-        if (dir !== null)
-            await rm(dir, { recursive: true, force: true });
+        await snapshot.cleanup();
     }
 }
 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 });
+        const report = await scanFromSnapshot(project, { ...options, noRemoteResolution });
         return jsonResult({
             project_dir: project.projectDir,
             dependency_resolution: dependencyResolution(noRemoteResolution, TRANSITIVE_OMITTED_WARNING),

package/dist/tools/suggestFix.js

@@ -3,10 +3,10 @@
  * scan_java_projectと同じスキャンを実行し、脆弱なパッケージごとの
  * 推奨アップグレードバージョン(3段階Tier)を返す。
  */
-import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
+import { isRemoteResolutionDisabled } from "../osv/runner.js";
 import { suggestUpgrades } from "../osv/suggestFix.js";
 import { detectJavaProject } from "../utils/projectDetector.js";
-import { dependencyResolution, skippedManifestsFields, } from "./scanJavaProject.js";
+import { dependencyResolution, scanJavaManifests, skippedManifestsFields, } from "./scanJavaProject.js";
 import { errorResult, jsonResult } from "./toolResult.js";
 export async function handleSuggestFix(args, options = {}) {
     try {
@@ -14,13 +14,13 @@ export async function handleSuggestFix(args, options = {}) {
             allowedRoot: options.allowedRoot,
         });
         const noRemoteResolution = isRemoteResolutionDisabled(options);
-        const report = await runOsvScan(project.targets, { ...options, noRemoteResolution });
+        const { manifests, skipped, incomplete, report } = await scanJavaManifests(project, { ...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),
+            manifests,
+            ...skippedManifestsFields(skipped, incomplete),
             dependency_resolution: dependencyResolution(noRemoteResolution),
             vulnerable_package_count: suggestions.length,
             unfixed_vulnerability_count: unfixedVulnerabilities,

package/dist/utils/manifestDetector.js

@@ -7,12 +7,12 @@
  *
  * 検出・除外の根拠はdocs/DESIGN_TODO.md「対象エコシステム拡大 詳細設計メモ」を参照。
  */
-import { readFile, stat } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
-import { pomParentOutsideRoot } from "./pomParent.js";
 import { assertInsideAllowedRoot, resolveExistingPath, walkProjectFiles, } from "./projectWalk.js";
-import { analyzeRequirementsFile, } from "./requirementsFile.js";
+import { readRegularFile } from "./safeRead.js";
+import { analyzeRequirementsFile, createRequirementsReadContext, } from "./requirementsFile.js";
 /** ファイル名→(エコシステム, 解析形式)。npm-shrinkwrap.jsonはpackage-lock.json形式で解析する */
 const LOCKFILES = new Map([
     ["pom.xml", { ecosystem: "Maven", format: "pom.xml" }],
@@ -73,26 +73,54 @@ function satisfiesGroup(manifest, group) {
 function isSameOrDescendant(dir, ancestor) {
     return ancestor === "." || dir === ancestor || dir.startsWith(`${ancestor}${path.sep}`);
 }
-/** workspaceの収録確認で読むlockfileの上限 */
+/** workspaceの収録確認で読むlockfile1件の上限と、1回の検出での合計の上限 */
 const MAX_LOCKFILE_BYTES = 64 * 1024 * 1024;
+const MAX_LOCKFILE_TOTAL_BYTES = 256 * 1024 * 1024;
+/**
+ * workspaceの収録確認用に、package-lock.jsonの`packages`のキー一覧を1回だけ読む。
+ * package.jsonの数だけ同じlockfileを解析し直すと、巨大なlockfileで負荷が増大するため、
+ * lockfileごとに結果を使い回し、読む量の合計にも上限を設ける。
+ */
+export class LockfileKeyCache {
+    keys = new Map();
+    remaining;
+    constructor(maxTotalBytes = MAX_LOCKFILE_TOTAL_BYTES) {
+        this.remaining = maxTotalBytes;
+    }
+    /** 収録済みのキー。null=確認できない(v1形式・読めない・大きすぎる・上限超過) */
+    async get(lockAbs, projectDir) {
+        if (this.keys.has(lockAbs))
+            return this.keys.get(lockAbs);
+        let keys = null;
+        if (this.remaining > 0) {
+            const read = await readRegularFile(lockAbs, { maxBytes: Math.min(MAX_LOCKFILE_BYTES, this.remaining), boundary: projectDir });
+            if (read.ok) {
+                this.remaining -= read.bytes.length;
+                try {
+                    const packages = JSON.parse(read.bytes.toString("utf8")).packages;
+                    if (typeof packages === "object" && packages !== null)
+                        keys = new Set(Object.keys(packages));
+                }
+                catch {
+                    keys = null;
+                }
+            }
+        }
+        this.keys.set(lockAbs, keys);
+        return keys;
+    }
+}
 /**
  * package-lock.json(v2以降)の`packages`に、memberDirのエントリがあるか。
- * true=収録 / false=未収録 / null=確認できない(v1形式・読めない・大きすぎる)
+ * true=収録 / false=未収録 / null=確認できない
  */
-async function npmLockfileRecords(projectDir, lockfile, memberDir) {
+async function npmLockfileRecords(cache, projectDir, lockfile, memberDir) {
     const lockAbs = path.join(projectDir, lockfile.path);
-    try {
-        if ((await stat(lockAbs)).size > MAX_LOCKFILE_BYTES)
-            return null;
-        const packages = JSON.parse(await readFile(lockAbs, "utf8")).packages;
-        if (typeof packages !== "object" || packages === null)
-            return null;
-        const key = path.relative(path.dirname(lockAbs), path.join(projectDir, memberDir)).split(path.sep).join("/");
-        return Object.hasOwn(packages, key);
-    }
-    catch {
+    const keys = await cache.get(lockAbs, projectDir);
+    if (keys === null)
         return null;
-    }
+    const key = path.relative(path.dirname(lockAbs), path.join(projectDir, memberDir)).split(path.sep).join("/");
+    return keys.has(key);
 }
 /**
  * lockfileの無いマーカー(package.json等)を判定する。
@@ -101,6 +129,7 @@ async function npmLockfileRecords(projectDir, lockfile, memberDir) {
  *   workspace設定の無いルートのlockfileで、独立した子プロジェクトの欠落を隠さないため
  */
 async function findLockfileMissing(projectDir, markers, manifests) {
+    const cache = new LockfileKeyCache();
     const missing = [];
     for (const marker of markers) {
         const markerDir = path.dirname(marker.path);
@@ -116,7 +145,7 @@ async function findLockfileMissing(projectDir, markers, manifests) {
         let recorded = false;
         for (const candidate of candidates) {
             const result = candidate.format === "package-lock.json"
-                ? await npmLockfileRecords(projectDir, candidate, markerDir)
+                ? await npmLockfileRecords(cache, projectDir, candidate, markerDir)
                 : null;
             if (result === true)
                 recorded = true;
@@ -139,6 +168,7 @@ async function findLockfileMissing(projectDir, markers, manifests) {
 async function finalize(projectDir, manifests, markers, allowedRootReal) {
     const result = {
         projectDir,
+        allowedRootReal,
         manifests: [],
         targets: [],
         requirementsCopies: [],
@@ -148,10 +178,11 @@ async function finalize(projectDir, manifests, markers, allowedRootReal) {
         lowerBounds: [],
         skippedFiles: [],
     };
+    const readContext = createRequirementsReadContext();
     for (const manifest of manifests) {
         const absolute = path.join(projectDir, manifest.path);
         if (manifest.format === "requirements.txt") {
-            const analysis = await analyzeRequirementsFile(absolute, projectDir);
+            const analysis = await analyzeRequirementsFile(absolute, projectDir, readContext);
             if (!analysis.ok) {
                 result.skippedFiles.push({ path: manifest.path, reason: analysis.reason });
                 continue;
@@ -162,11 +193,6 @@ async function finalize(projectDir, manifests, markers, allowedRootReal) {
             result.requirementsCopies.push({ path: manifest.path, entries: analysis.entries });
         }
         else {
-            const outside = manifest.format === "pom.xml" ? await pomParentOutsideRoot(absolute, allowedRootReal) : null;
-            if (outside !== null) {
-                result.skippedFiles.push({ path: manifest.path, reason: outside });
-                continue;
-            }
             result.targets.push({ path: absolute, format: manifest.format });
         }
         result.manifests.push(manifest);