osv-scanner-mcp 0.1.11 → 0.2.0

package/README.md

@@ -12,6 +12,7 @@ Google製 [OSV-Scanner](https://github.com/google/osv-scanner) をラップす
 ## 特徴
 
 - **ワンショットスキャン**: `scan_java_project` ツールにプロジェクトパスを渡すだけで、検出→スキャン→整形済みレポートまで一気に返します
+- **JAR/WAR実体スキャン**: `scan_java_artifact` ツールで、lockfileが無い・shaded/fat JARしか手元にないプロジェクトでもアーカイブ内メタデータから既知の脆弱性を検出します(ベストエフォート同定であることを明示するcoverage情報付き)
 - **深刻度順のレポート**: パッケージごとに脆弱性をCVSSスコア順に整理し、5段階の深刻度ラベル(critical / high / medium / low / unknown)とサマリ集計付きで返します
 - **修正版の提示**: 各脆弱性の `fixed_versions` をMavenバージョン優先順位規則で正しくソートして含めます(`2.17.1-RELEASE` のようなsemver非対応の表記にも対応)
 - **セキュリティ第一の設計**: シェル非経由の実行・引数ホワイトリスト・パス正規化と境界チェック・タイムアウト/出力サイズ上限を実装段階から組み込んでいます
@@ -178,6 +179,33 @@ Java(Maven)プロジェクトをスキャンし、既知の脆弱性レポート
 - `fixed_versions` はMaven優先順位で昇順。複数のリリース系統(例: 2.12系バックポートと2.15系)が混在することがあります。空配列は「修正版が存在しない」ことを意味します
 - `severity_score` が取得できない脆弱性は `null` / `"unknown"` として扱います
 
+### `scan_java_artifact`
+
+JAR/WARファイルの実体をスキャンします。既存のマニフェスト方式とは別ツールです。
+
+```json
+{ "artifact_path": "/absolute/path/to/application.war" }
+```
+
+`artifact_path` はJAR/WARファイル、または探索するディレクトリの絶対パスです。
+ディレクトリ指定では `target` や `build` も探索します。`.git`、`node_modules`、`.idea`、`.vscode` と探索中のシンボリックリンクは除外します。
+探索上限は深さ8・100ファイル・10,000エントリです。上限に達して探索を完了できない場合は、結果を黙って省略せず `artifact_search_limit_exceeded` を返します。対象を絞って再実行してください。
+`OSV_MCP_ALLOWED_ROOT` による制限も適用されます。
+
+OSV-Scanner 2.4.0の `java/archive` プラグインを使用し、ネストJARもスキャナー側で解析します。Javaコードやビルドは実行しません。
+識別にはアーカイブ内メタデータを用いるため、除去済みメタデータやshaded/minimized JAR内の依存を見落とす場合があります。
+
+**出力の読み方:**
+
+- 先頭の `coverage` に `jars_found`、`jars_identified`、`unidentified_jars` を返します。件数はWARも含む、ファイルシステム上で列挙した外側のアーカイブ単位です。ネストJARの総数ではありません。
+- `artifacts[].status` は `identified_with_vulnerabilities` / `identified_without_known_vulnerabilities` / `unidentified` の3値です。「同定済み」は少なくとも1件のMaven座標を取得できた意味であり、全依存の同定ではありません。
+- `coverage.completeness` は常に `incomplete`。`identified_vulnerability_count: 0` は安全性の保証ではありません。
+- `packages` は同定できた脆弱なパッケージの詳細です。複数アーカイブに含まれる同一パッケージ・脆弱性は全体集計では重複排除します。
+- JAR/WARが無い場合は `no_scannable_artifacts`、全件同定不能の場合は警告を含む成功レポートです。
+
+`suggest_fix` は引き続きマニフェスト方式専用です。experimentalプラグインを使うため、OSV-Scannerのピン留めバージョン更新時には、フラグとJAR/WARの出力形式も再検証してください。
+信頼できないアーカイブの展開はOSV-Scannerのネイティブ処理に依存します。タイムアウト・出力上限はありますが、OSレベルのメモリ制限やサンドボックスを提供するものではありません。
+
 ### `suggest_fix`
 
 スキャンを実行し、脆弱なパッケージごとに**推奨アップグレードバージョン**を提案します。単純な最大バージョンではなく、現在のバージョンに最も近いリリース系統の修正版を3段階フォールバックで選定します:
@@ -205,7 +233,8 @@ Java(Maven)プロジェクトをスキャンし、既知の脆弱性レポート
       "ecosystem": "Maven",
       "recommended_upgrade": "2.25.4",
       "upgrade_tier": "major_internal",
-      "upgrade_note": "2.14系統向けの修正版は存在しない。同一メジャー(2.x)内では2.25.4が7件のCVEを解消する最小版",
+      "verification": "verified",
+      "upgrade_note": "取得済みの影響範囲に基づき修正対象CVEの範囲外と確認した候補です",
       "per_cve_detail": [
         { "id": "GHSA-jfh8-c2jp-5v3q", "cve": "CVE-2021-44228", "severity": "critical", "fixed_in": "2.15.0", "tier": "major_internal" }
       ]
@@ -214,8 +243,10 @@ Java(Maven)プロジェクトをスキャンし、既知の脆弱性レポート
 }
 ```
 
-- `recommended_upgrade` は「修正可能な全CVEを解消できる最小バージョン」(CVEごとのTier結果の最大値)
-- 修正版が存在しない(または現在より新しい修正版がない)CVEは `tier: "unfixed"` として明示し、推奨計算から除外します。全CVEがunfixedの場合 `recommended_upgrade` は `null`
+- `recommended_upgrade` は既知の修正版を候補に、修正対象の全CVEの影響範囲外と確認できたものを3段階Tier順・バージョン昇順で選びます。CVEごとの修正版の最大値を単純に採用せず、別系統で再び影響を受ける候補も除外します。全公開版の中での最小性や未検出の脆弱性がないことは保証しません。
+- 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` です。
 
 ### `explain_vulnerability`
 
@@ -294,6 +325,7 @@ npm run build             # dist/ へビルド
 - [x] npmパッケージ化(`npx osv-scanner-mcp`)
 - [x] OSV-Scannerバイナリの自動ダウンロード(チェックサム検証付き)
 - [x] Gradle対応(lockfile方式)
+- [x] `scan_java_artifact` ツール: JAR/WAR実体スキャン(lockfileが無い・shaded/fat JARのみのプロジェクト向け)
 
 ## ライセンス
 

package/dist/index.js

@@ -15,6 +15,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 { handleScanJavaArtifact } from "./tools/scanJavaArtifact.js";
 import { handleSuggestFix } from "./tools/suggestFix.js";
 import { ALLOWED_ROOT_ENV, allowedRootStartupError, allowedRootStartupWarning, } from "./utils/startupConfig.js";
 export { ALLOWED_ROOT_ENV };
@@ -32,7 +33,7 @@ if (startupWarning !== null) {
 // NOTE: リリース時はpackage.jsonのversionと同じ値に更新すること
 const server = new McpServer({
     name: "osv-scanner-mcp",
-    version: "0.1.11",
+    version: "0.2.0",
 });
 server.registerTool("scan_java_project", {
     title: "Javaプロジェクトの脆弱性スキャン",
@@ -52,7 +53,8 @@ server.registerTool("suggest_fix", {
         "現在のバージョンに最も近いリリース系統の修正版を優先する3段階フォールバック" +
         "(same_minor: 同一major.minor系統内 → major_internal: 同一メジャー内 → cross_major: メジャーアップグレード)で選定し、" +
         "推奨バージョン・アップグレード距離(upgrade_tier)・CVEごとの修正版を返す。" +
-        "修正版が存在しないCVEはunfixedとして明示する。Maven(pom.xml)とGradle(gradle.lockfile)に対応。",
+        "候補を全修正対象CVEの影響範囲と照合し、情報不足の場合は推奨を保留する。" +
+        "現在より新しい修正版候補のないCVEはunfixedとして別表示し、推奨先での判定も返す。Maven(pom.xml)とGradle(gradle.lockfile)に対応。",
     inputSchema: {
         project_path: z
             .string()
@@ -73,6 +75,15 @@ server.registerTool("explain_vulnerability", {
             .describe("脆弱性のID(例: GHSA-jfh8-c2jp-5v3q、CVE-2021-44228)"),
     },
 }, async ({ vulnerability_id }) => handleExplainVulnerability({ vulnerability_id }));
+server.registerTool("scan_java_artifact", {
+    title: "JAR/WAR実体の脆弱性スキャン",
+    description: "JAR/WARファイルまたはディレクトリ内の実体をスキャンする。ビルドやJavaコードの実行は行わない。" +
+        "メタデータによるベストエフォート同定のため、coverageと同定不能ファイルを必ず確認すること。" +
+        "completenessは常にincomplete。検出0件でも安全性や全依存の同定を保証しない。",
+    inputSchema: {
+        artifact_path: z.string().min(1).describe("JAR/WARファイル、または探索するディレクトリの絶対パス"),
+    },
+}, async ({ artifact_path }) => handleScanJavaArtifact({ artifact_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
 const transport = new StdioServerTransport();
 await server.connect(transport);
 // stdoutはMCPプロトコル専用のため、起動ログはstderrへ

package/dist/osv/affectedVersions.js

@@ -0,0 +1,97 @@
+import { compareMavenVersions } from "../utils/mavenVersion.js";
+import { asArray, asRecord, asString } from "../utils/unknownJson.js";
+/** Preserve uncertainty: unsupported or malformed ranges cannot prove a candidate safe. */
+export function extractAffectedVersions(details, ids, name, ecosystem) {
+    const evidence = { complete: ecosystem === "Maven", intervals: [], versions: [] };
+    if (ids.length === 0 || ids.some(id => !details.some(d => d.id === id)))
+        evidence.complete = false;
+    for (const detail of details) {
+        let matched = false;
+        for (const raw of asArray(detail.affected)) {
+            const affected = asRecord(raw);
+            const pkg = asRecord(affected?.package);
+            if (asString(pkg?.name) !== name || asString(pkg?.ecosystem) !== ecosystem) {
+                if (!asString(pkg?.name) || !asString(pkg?.ecosystem))
+                    evidence.complete = false;
+                continue;
+            }
+            matched = true;
+            if (affected?.versions !== undefined && !Array.isArray(affected.versions))
+                evidence.complete = false;
+            for (const version of asArray(affected?.versions)) {
+                const value = asString(version);
+                if (!value)
+                    evidence.complete = false;
+                else
+                    evidence.versions.push(value);
+            }
+            const ranges = asArray(affected?.ranges);
+            // A versions-only list does not establish that unlisted releases are unaffected.
+            if (ranges.length === 0)
+                evidence.complete = false;
+            for (const rawRange of ranges) {
+                const range = asRecord(rawRange);
+                if (range?.type !== "ECOSYSTEM") {
+                    evidence.complete = false;
+                    continue;
+                }
+                const events = asArray(range.events);
+                let start = null;
+                let previousEnd = null;
+                let previousInclusive = false;
+                if (events.length === 0)
+                    evidence.complete = false;
+                for (const rawEvent of events) {
+                    const event = asRecord(rawEvent);
+                    const keys = event ? Object.keys(event) : [];
+                    const kind = keys[0];
+                    const value = kind ? asString(event?.[kind]) : null;
+                    if (keys.length !== 1 || !value || !["introduced", "fixed", "last_affected", "limit"].includes(kind)) {
+                        evidence.complete = false;
+                        continue;
+                    }
+                    if (kind === "introduced") {
+                        if (start !== null || (previousEnd !== null && (value === "0" ||
+                            compareMavenVersions(value, previousEnd) < 0 ||
+                            (previousInclusive && compareMavenVersions(value, previousEnd) === 0))))
+                            evidence.complete = false;
+                        start = value;
+                    }
+                    else {
+                        if (start === null) {
+                            evidence.complete = false;
+                            continue;
+                        }
+                        const inclusive = kind === "last_affected";
+                        if (start !== "0" && (compareMavenVersions(start, value) > 0 ||
+                            (!inclusive && compareMavenVersions(start, value) === 0)))
+                            evidence.complete = false;
+                        evidence.intervals.push({ introduced: start, end: value, inclusive });
+                        // limit bounds known affected versions, but is not evidence of a fix beyond it.
+                        if (kind === "limit")
+                            evidence.complete = false;
+                        previousEnd = value;
+                        previousInclusive = inclusive;
+                        start = null;
+                    }
+                }
+                if (start !== null)
+                    evidence.intervals.push({ introduced: start, end: null, inclusive: false });
+            }
+        }
+        if (!matched)
+            evidence.complete = false;
+    }
+    if (details.length === 0)
+        evidence.complete = false;
+    return evidence;
+}
+export function candidateStatus(evidence, version) {
+    if (!evidence)
+        return "unknown";
+    if (evidence.versions.some(v => compareMavenVersions(v, version) === 0) || evidence.intervals.some(r => (r.introduced === "0" || compareMavenVersions(version, r.introduced) >= 0) &&
+        (r.end === null || compareMavenVersions(version, r.end) < 0 ||
+            (r.inclusive && compareMavenVersions(version, r.end) === 0))))
+        return "affected";
+    return evidence.complete ? "not_affected" : "unknown";
+}

package/dist/osv/artifactReport.js

@@ -0,0 +1,60 @@
+import { ScanToolError } from "../errors.js";
+import { sanitizeExternalText } from "../utils/externalText.js";
+import { asArray, asRecord } from "../utils/unknownJson.js";
+import { parseOsvScanOutput } from "./scanReport.js";
+const WARNING = "Best-effort metadata identification only. Missing or removed metadata can hide dependencies, even in identified archives. Zero identified vulnerabilities does not establish safety.";
+const HINT = "Metadata may be missing (shaded/minimized archive). Scan the build project's lockfile instead.";
+function isIdentifiedPackage(raw) {
+    const info = asRecord(asRecord(raw)?.package);
+    if (info?.ecosystem !== "Maven" || typeof info.name !== "string" || typeof info.version !== "string")
+        return false;
+    const parts = info.name.split(":");
+    return parts.length === 2 && parts.every((part) => part.trim() !== "" && part.toLowerCase() !== "unknown") &&
+        info.version.trim() !== "" && info.version.toLowerCase() !== "unknown";
+}
+export function buildArtifactReport(raw, artifactPaths) {
+    const results = asRecord(raw)?.results;
+    if (!Array.isArray(results)) {
+        throw new ScanToolError("invalid_output", "OSV-Scanner artifact output is missing its results array");
+    }
+    const byPath = new Map();
+    for (const result of results) {
+        const record = asRecord(result);
+        const source = asRecord(record?.source);
+        // Identity comparison must precede display sanitization, which can collapse distinct names.
+        const sourcePath = source?.path;
+        if (source?.type !== "artifact" || typeof sourcePath !== "string" || !artifactPaths.includes(sourcePath))
+            continue;
+        const packages = asArray(record?.packages).filter(isIdentifiedPackage);
+        if (packages.length > 0)
+            byPath.set(sourcePath, [...(byPath.get(sourcePath) ?? []), ...packages]);
+    }
+    const normalized = [...byPath].map(([file, packages]) => ({ source: { path: file }, packages }));
+    const report = parseOsvScanOutput({ results: normalized });
+    const artifacts = artifactPaths.map((file) => {
+        const packages = byPath.get(file);
+        const identified = packages !== undefined;
+        const perFile = parseOsvScanOutput({ results: [{ packages: packages ?? [] }] });
+        return {
+            path: sanitizeExternalText(file),
+            status: !identified ? "unidentified" : perFile.vulnerability_count > 0
+                ? "identified_with_vulnerabilities" : "identified_without_known_vulnerabilities",
+            identified_vulnerability_count: perFile.vulnerability_count,
+        };
+    });
+    return {
+        coverage: {
+            jars_found: artifactPaths.length,
+            jars_identified: byPath.size,
+            unidentified_jars: artifacts.filter((item) => item.status === "unidentified")
+                .map(({ path }) => ({ path, hint: HINT })),
+            completeness: "incomplete",
+            warning: WARNING,
+        },
+        artifacts,
+        identified_vulnerability_count: report.vulnerability_count,
+        identified_vulnerable_package_count: report.vulnerable_package_count,
+        severity_breakdown: report.severity_breakdown,
+        packages: report.packages,
+    };
+}

package/dist/osv/binaryDownloader.js

@@ -15,6 +15,7 @@ import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
 import os from "node:os";
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
+import { readResponseBytes } from "../utils/readResponseBytes.js";
 /** ピン留めするOSV-Scannerのバージョン。更新時は下のチェックサムも必ず更新すること */
 export const PINNED_OSV_SCANNER_VERSION = "2.4.0";
 /**
@@ -70,15 +71,14 @@ async function downloadAsset(url, fetchFn, timeoutMs) {
     if (!response.ok) {
         throw new ScanToolError("binary_download_failed", `OSV-Scannerのダウンロードに失敗しました(HTTP ${response.status}): ${url}`);
     }
-    const contentLength = Number(response.headers.get("content-length") ?? "0");
-    if (contentLength > MAX_BINARY_BYTES) {
-        throw new ScanToolError("binary_download_failed", `ダウンロードサイズが上限(${MAX_BINARY_BYTES}バイト)を超えています`);
+    try {
+        return await readResponseBytes(response, MAX_BINARY_BYTES, new ScanToolError("binary_download_failed", `ダウンロードサイズが上限(${MAX_BINARY_BYTES}バイト)を超えています`));
     }
-    const buffer = Buffer.from(await response.arrayBuffer());
-    if (buffer.byteLength > MAX_BINARY_BYTES) {
-        throw new ScanToolError("binary_download_failed", `ダウンロードサイズが上限(${MAX_BINARY_BYTES}バイト)を超えています`);
+    catch (error) {
+        if (error instanceof ScanToolError)
+            throw error;
+        throw new ScanToolError("binary_download_failed", "OSV-Scannerのダウンロード本文を受信できませんでした");
     }
-    return buffer;
 }
 /**
  * ピン留めバージョンのOSV-Scannerをキャッシュから返す。

package/dist/osv/osvApi.js

@@ -9,6 +9,7 @@
  * - レスポンスは外部由来データとして防御的にパースする(呼び出し側)
  */
 import { ScanToolError } from "../errors.js";
+import { readResponseBytes } from "../utils/readResponseBytes.js";
 const DEFAULT_TIMEOUT_MS = 15_000;
 const DEFAULT_MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
 const DEFAULT_BASE_URL = "https://api.osv.dev";
@@ -56,14 +57,15 @@ export async function fetchOsvRecord(id, options = {}) {
     if (!response.ok) {
         throw new ScanToolError("api_request_failed", `OSV APIがエラーを返しました(HTTP ${response.status})`);
     }
-    const contentLength = Number(response.headers.get("content-length") ?? "0");
-    if (contentLength > maxBytes) {
-        throw new ScanToolError("output_too_large", `OSV APIのレスポンスがサイズ上限(${maxBytes}バイト)を超えました`);
+    let body;
+    try {
+        const bytes = await readResponseBytes(response, maxBytes, new ScanToolError("output_too_large", `OSV APIのレスポンスがサイズ上限(${maxBytes}バイト)を超えました`));
+        body = new TextDecoder().decode(bytes);
     }
-    const body = await response.text();
-    // 文字数(UTF-16単位)ではなくUTF-8バイト数で判定する(マルチバイト本文のズレ防止)
-    if (Buffer.byteLength(body, "utf8") > maxBytes) {
-        throw new ScanToolError("output_too_large", `OSV APIのレスポンスがサイズ上限(${maxBytes}バイト)を超えました`);
+    catch (error) {
+        if (error instanceof ScanToolError)
+            throw error;
+        throw new ScanToolError("api_request_failed", "OSV APIのレスポンス本文を受信できませんでした");
     }
     try {
         return JSON.parse(body);

package/dist/osv/runner.js

@@ -4,7 +4,7 @@
  * セキュリティ設計(docs/DESIGN_TODO.md):
  * - シェルを経由しない`spawn`+引数配列で実行(コマンドインジェクション対策)
  * - OSV-Scannerへ渡す引数は固定リストのみ。呼び出し側から任意フラグは注入できない
- *   (対象パスは位置引数1つだけで、projectDetectorでrealpath解決済みの絶対パスを渡す)
+ *   (プロジェクトは検証済みディレクトリ1つ、実体スキャンは列挙済みのJAR/WAR絶対パスだけを渡す)
  * - タイムアウトと出力サイズ上限を設ける(ハング・巨大出力によるDoS対策)
  *
  * 終了コード(2.4.0で実機確認):
@@ -38,12 +38,18 @@ const DEFAULT_MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
 const MAX_STDERR_DETAIL_BYTES = 8 * 1024;
 /** OSV-Scannerに渡す固定引数。ここに無いオプションは一切使わない(ホワイトリスト) */
 const FIXED_SCAN_ARGS = ["scan", "source", "-r", "--format", "json"];
+const FIXED_ARTIFACT_ARGS = [
+    "scan", "source", "--format", "json", "--all-packages", "--no-ignore",
+    "--experimental-no-default-plugins", "--experimental-plugins", "java/archive",
+];
 const EXIT_NO_VULNS = 0;
 const EXIT_VULNS_FOUND = 1;
 const EXIT_NO_PACKAGES = 128;
-function execOsvScanner(binaryPath, projectDir, timeoutMs, maxOutputBytes) {
+function execOsvScanner(binaryPath, targetPaths, timeoutMs, maxOutputBytes, artifactMode) {
     return new Promise((resolve, reject) => {
-        const child = spawn(binaryPath, [...FIXED_SCAN_ARGS, projectDir], {
+        const child = spawn(binaryPath, [
+            ...(artifactMode ? FIXED_ARTIFACT_ARGS : FIXED_SCAN_ARGS), ...targetPaths,
+        ], {
             shell: false,
             stdio: ["ignore", "pipe", "pipe"],
         });
@@ -101,25 +107,39 @@ function execOsvScanner(binaryPath, projectDir, timeoutMs, maxOutputBytes) {
  *   絶対パスを渡すこと**(このレイヤーではパス検証を行わない)
  */
 export async function runOsvScan(projectDir, options = {}) {
+    return parseOsvScanOutput(await runScan([projectDir], options, false));
+}
+/** Accept only the exact absolute files enumerated by detectJavaArtifacts. */
+export async function runOsvArtifactScan(artifactPaths, options = {}) {
+    if (artifactPaths.length === 0) {
+        throw new ScanToolError("no_scannable_artifacts", "No JAR/WAR archives selected");
+    }
+    return runScan(artifactPaths, options, true);
+}
+async function runScan(targetPaths, options, artifactMode) {
     const limit = options.maxConcurrentScans ?? maxConcurrentScansFromEnv();
     if (activeScans >= limit) {
         throw new ScanToolError("too_many_concurrent_scans", `同時実行できるスキャンは${limit}件までです(現在${activeScans}件実行中)。実行中のスキャン完了後に再試行してください`);
     }
     activeScans++;
     try {
-        return await runOsvScanUnguarded(projectDir, options);
+        return await runOsvScanUnguarded(targetPaths, options, artifactMode);
     }
     finally {
         activeScans--;
     }
 }
-async function runOsvScanUnguarded(projectDir, options) {
+async function runOsvScanUnguarded(targetPaths, options, artifactMode) {
     const binaryPath = options.binaryPath ?? (await resolveOsvScannerBinary());
-    const result = await execOsvScanner(binaryPath, projectDir, options.timeoutMs ?? DEFAULT_TIMEOUT_MS, options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES);
-    if (result.exitCode === EXIT_NO_PACKAGES) {
-        throw new ScanToolError("no_packages_found", `OSV-Scannerがスキャン対象のパッケージを検出できませんでした: ${projectDir}(pom.xmlに依存関係が定義されているか確認してください)`, result.stderr);
+    const result = await execOsvScanner(binaryPath, targetPaths, options.timeoutMs ?? DEFAULT_TIMEOUT_MS, options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES, artifactMode);
+    if (result.exitCode === EXIT_NO_PACKAGES && !artifactMode) {
+        throw new ScanToolError("no_packages_found", `OSV-Scannerがスキャン対象のパッケージを検出できませんでした: ${targetPaths[0]}(pom.xmlに依存関係が定義されているか確認してください)`, result.stderr);
+    }
+    if (artifactMode && result.exitCode === EXIT_NO_PACKAGES && result.stdout.trim() === "") {
+        return { results: [] };
     }
-    if (result.exitCode !== EXIT_NO_VULNS && result.exitCode !== EXIT_VULNS_FOUND) {
+    if (result.exitCode !== EXIT_NO_VULNS && result.exitCode !== EXIT_VULNS_FOUND &&
+        !(artifactMode && result.exitCode === EXIT_NO_PACKAGES)) {
         const status = result.exitCode !== null ? `exit code ${result.exitCode}` : `signal ${result.signal}`;
         throw new ScanToolError("scan_failed", `OSV-Scannerが異常終了しました(${status})`, result.stderr);
     }
@@ -130,5 +150,5 @@ async function runOsvScanUnguarded(projectDir, options) {
     catch {
         throw new ScanToolError("invalid_output", "OSV-Scannerの出力をJSONとして解釈できませんでした", result.stdout.slice(0, 1000));
     }
-    return parseOsvScanOutput(parsed);
+    return parsed;
 }

package/dist/osv/scanReport.js

@@ -14,6 +14,7 @@
  */
 import { compareMavenVersions } from "../utils/mavenVersion.js";
 import { asArray, asRecord, asString, asStrings } from "../utils/unknownJson.js";
+import { extractAffectedVersions } from "./affectedVersions.js";
 /** 外部由来のsummaryをLLMに渡す際の長さ上限(プロンプト肥大・DoS対策) */
 const MAX_SUMMARY_LENGTH = 500;
 const CVSS_CRITICAL = 9.0;
@@ -65,7 +66,7 @@ function extractSummary(vulnDetails) {
  * OSVエントリの`affected[].ranges[].events[].fixed`から修正版を収集する。
  * 1つのOSVエントリが複数パッケージをカバーしうるため、対象パッケージ名で絞り込む。
  */
-function extractFixedVersions(vulnDetails, packageName) {
+function extractFixedVersions(vulnDetails, packageName, ecosystem) {
     const versions = new Set();
     for (const detail of vulnDetails) {
         for (const affectedRaw of asArray(detail.affected)) {
@@ -73,9 +74,11 @@ function extractFixedVersions(vulnDetails, packageName) {
             if (!affected)
                 continue;
             const affectedName = asString(asRecord(affected.package)?.name);
-            if (affectedName !== null && affectedName !== packageName)
+            if (affectedName !== packageName || asString(asRecord(affected.package)?.ecosystem) !== ecosystem)
                 continue;
             for (const rangeRaw of asArray(affected.ranges)) {
+                if (asRecord(rangeRaw)?.type !== "ECOSYSTEM" || ecosystem !== "Maven")
+                    continue;
                 for (const eventRaw of asArray(asRecord(rangeRaw)?.events)) {
                     const fixed = asString(asRecord(eventRaw)?.fixed);
                     if (fixed !== null && fixed !== "")
@@ -139,7 +142,8 @@ export function parseOsvScanOutput(raw) {
                     severity_score: score,
                     severity: severityFromScore(score),
                     summary: extractSummary(vulnDetails),
-                    fixed_versions: extractFixedVersions(vulnDetails, name),
+                    fixed_versions: extractFixedVersions(vulnDetails, name, ecosystem),
+                    affected_versions: extractAffectedVersions(vulnDetails, ids, name, ecosystem),
                 });
             }
         }

package/dist/osv/suggestFix.js

@@ -10,11 +10,12 @@
  *   Tier 2 (major_internal): 同一メジャー内の最小の修正版(マイナーバージョンアップ)
  *   Tier 3 (cross_major):    全体最小の修正版(メジャーアップグレード、破壊的変更の可能性)
  *
- * パッケージ全体の推奨(recommended_upgrade)は全CVEのTier結果の最大値
- * (= すべての修正可能なCVEを解消できる最小バージョン)。
+ * パッケージ全体の候補を全修正対象CVEの影響範囲と照合して推奨する。
+ * 判定不能な候補は推奨しない。
  * 現在より新しい修正版が存在しないCVEはunfixedとして明示し、推奨計算から除外する。
  */
 import { compareMavenVersions, mavenVersionSeries } from "../utils/mavenVersion.js";
+import { candidateStatus } from "./affectedVersions.js";
 function classifyTier(currentSeries, candidate) {
     const candidateSeries = mavenVersionSeries(candidate);
     if (currentSeries === null || candidateSeries === null)
@@ -48,26 +49,26 @@ function pickFixForCve(currentVersion, currentSeries, fixedVersions) {
 }
 function buildNote(currentSeries, recommended, tier, fixableCount, unfixedCount) {
     if (recommended === null) {
-        return `全${unfixedCount}件のCVEに現在より新しい修正版が存在しない(unfixed)`;
+        return `全${unfixedCount}件のCVEに現在より新しい修正版候補がない(unfixed)。修正版情報の欠落を含む可能性があります`;
     }
     const label = currentSeries !== null ? `${currentSeries.major}.${currentSeries.minor}` : null;
     let note;
     switch (tier) {
         case "same_minor":
-            note = `現在の${label}系統内の${recommended}で、修正版が存在する${fixableCount}件のCVEをすべて解消できる`;
+            note = `現在の${label}系統内の候補${recommended}を推奨`;
             break;
         case "major_internal":
-            note = `${label}系統向けの修正版は存在しない。同一メジャー(${currentSeries.major}.x)内では${recommended}が${fixableCount}件のCVEを解消する最小版`;
+            note = `同一メジャー(${currentSeries.major}.x)内の候補${recommended}を推奨`;
             break;
         default:
             note =
                 label !== null
-                    ? `同一メジャー(${currentSeries.major}.x)内に修正版が存在しない。${recommended}へのメジャーアップグレードが必要(破壊的変更の可能性あり)`
-                    : `現在バージョンの系統を判定できないため、全体最小の修正版${recommended}を提示`;
-    }
-    if (unfixedCount > 0) {
-        note += `。残り${unfixedCount}件は修正版が存在せず、このアップグレードでは解消されない`;
+                    ? `候補${recommended}へのメジャーアップグレードを推奨(破壊的変更の可能性あり)`
+                    : `現在バージョンの系統を判定できないため、検証済み候補${recommended}を提示`;
     }
+    note += `。取得済みの影響範囲に基づき修正対象${fixableCount}件のCVEの範囲外と確認しました。全公開版の最小性や未検出の脆弱性がないことは保証しません`;
+    if (unfixedCount > 0)
+        note += `。残り${unfixedCount}件は現在より新しい修正版候補がなく、修正対象から除外しています。recommended_statusを確認してください`;
     return note;
 }
 /** 1パッケージ分のアップグレード提案を組み立てる。 */
@@ -96,11 +97,26 @@ export function suggestUpgradeForPackage(pkg) {
             fixed_in: pick.version,
             tier: pick.tier,
         });
-        if (recommended === null || compareMavenVersions(pick.version, recommended) > 0) {
-            recommended = pick.version;
-        }
     }
     const fixableCount = details.length - unfixedCount;
+    const targets = pkg.vulnerabilities.filter((_, i) => details[i].fixed_in !== null);
+    const candidates = [...new Set(targets.flatMap(v => v.fixed_versions))]
+        .filter(v => compareMavenVersions(v, pkg.version) > 0)
+        .sort(compareMavenVersions);
+    const tierOrder = ["same_minor", "major_internal", "cross_major"];
+    recommended = null;
+    for (const tier of tierOrder) {
+        const candidate = candidates.find(v => classifyTier(currentSeries, v) === tier &&
+            targets.every(target => candidateStatus(target.affected_versions, v) === "not_affected"));
+        if (candidate !== undefined) {
+            recommended = candidate;
+            break;
+        }
+    }
+    for (let i = 0; i < details.length; i++) {
+        details[i].recommended_status = recommended === null ? "not_evaluated" :
+            candidateStatus(pkg.vulnerabilities[i].affected_versions, recommended);
+    }
     // 推奨バージョン自体のTierは「現在バージョンとの系統関係」で再分類する
     // (per-CVEのTierの寄せ集めではなく、実際に行うアップグレードの距離を表す)
     const upgradeTier = recommended !== null ? classifyTier(currentSeries, recommended) : null;
@@ -110,8 +126,11 @@ export function suggestUpgradeForPackage(pkg) {
         ecosystem: pkg.ecosystem,
         recommended_upgrade: recommended,
         upgrade_tier: upgradeTier,
-        upgrade_note: buildNote(currentSeries, recommended, upgradeTier, fixableCount, unfixedCount),
+        upgrade_note: recommended === null && fixableCount > 0
+            ? "既知の修正版候補から、全修正対象CVEの影響範囲外と確認できる版が見つかりません。情報不足・未対応の範囲形式を含む場合も推奨を保留します。"
+            : buildNote(currentSeries, recommended, upgradeTier, fixableCount, unfixedCount),
         per_cve_detail: details,
+        verification: recommended === null ? "no_verified_candidate" : "verified",
     };
 }
 /** スキャンレポート全体からパッケージごとの提案一覧を作る(深刻度順を維持)。 */

package/dist/tools/scanJavaArtifact.js

@@ -0,0 +1,14 @@
+import { buildArtifactReport } from "../osv/artifactReport.js";
+import { runOsvArtifactScan } from "../osv/runner.js";
+import { detectJavaArtifacts } from "../utils/artifactDetector.js";
+import { errorResult, jsonResult } from "./toolResult.js";
+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));
+    }
+    catch (error) {
+        return errorResult(error);
+    }
+}

package/dist/utils/artifactDetector.js

@@ -0,0 +1,61 @@
+import { opendir, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { ScanToolError } from "../errors.js";
+// Build output directories must be included for artifact scans.
+const SKIPPED_DIRS = new Set([".git", "node_modules", ".idea", ".vscode"]);
+const isArchive = (file) => /\.(jar|war)$/i.test(file);
+export async function detectJavaArtifacts(inputPath, options = {}) {
+    if (typeof inputPath !== "string" || inputPath.trim() === "" || !path.isAbsolute(inputPath)) {
+        throw new ScanToolError("project_not_found", "Specify an absolute JAR/WAR or directory path");
+    }
+    let targetPath;
+    try {
+        targetPath = await realpath(inputPath);
+    }
+    catch {
+        throw new ScanToolError("project_not_found", `Path does not exist: ${inputPath}`);
+    }
+    if (options.allowedRoot !== undefined) {
+        const root = await realpath(options.allowedRoot);
+        const relative = path.relative(root, targetPath);
+        if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+            throw new ScanToolError("path_outside_allowed_root", "Artifact path is outside the allowed root");
+        }
+    }
+    const info = await stat(targetPath);
+    if (info.isFile() && isArchive(targetPath))
+        return { targetPath, artifactPaths: [targetPath] };
+    if (!info.isDirectory()) {
+        throw new ScanToolError("no_scannable_artifacts", "The selected file is not a JAR/WAR archive");
+    }
+    const maxDepth = options.maxDepth ?? 8;
+    const maxArtifacts = options.maxArtifacts ?? 100;
+    const maxEntries = options.maxEntries ?? 10_000;
+    const artifactPaths = [];
+    let visited = 0;
+    const limitError = () => new ScanToolError("artifact_search_limit_exceeded", "Artifact discovery limit exceeded; select a smaller directory or an individual JAR/WAR");
+    async function walk(dir, depth) {
+        const entries = await opendir(dir);
+        for await (const entry of entries) {
+            if (++visited > maxEntries)
+                throw limitError();
+            const child = path.join(dir, entry.name);
+            if (entry.isFile() && isArchive(entry.name)) {
+                if (artifactPaths.length >= maxArtifacts)
+                    throw limitError();
+                artifactPaths.push(child);
+            }
+            else if (entry.isDirectory() && !SKIPPED_DIRS.has(entry.name)) {
+                if (depth >= maxDepth)
+                    throw limitError();
+                await walk(child, depth + 1);
+            }
+            // Dirent predicates do not follow symlinks. Never hand these to the scanner.
+        }
+    }
+    await walk(targetPath, 1);
+    if (artifactPaths.length === 0) {
+        throw new ScanToolError("no_scannable_artifacts", "No JAR/WAR archives found in the selected directory");
+    }
+    return { targetPath, artifactPaths: artifactPaths.sort() };
+}

package/dist/utils/readResponseBytes.js

@@ -0,0 +1,33 @@
+/** Read a fetch body without retaining more than the configured byte limit. */
+export async function readResponseBytes(response, maxBytes, sizeError) {
+    if (Number(response.headers.get("content-length")) > maxBytes) {
+        // Cleanup must not delay or replace the size-limit error.
+        void response.body?.cancel().catch(() => { });
+        throw sizeError;
+    }
+    if (response.body === null)
+        return Buffer.alloc(0);
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value.byteLength > maxBytes - total)
+                throw sizeError;
+            total += value.byteLength;
+            if (value.byteLength > 0)
+                chunks.push(value);
+        }
+        return Buffer.concat(chunks, total);
+    }
+    catch (error) {
+        void reader.cancel().catch(() => { });
+        throw error;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osv-scanner-mcp",
-  "version": "0.1.11",
+  "version": "0.2.0",
   "description": "MCP server that wraps Google's OSV-Scanner to scan Java projects for known vulnerabilities",
   "type": "module",
   "license": "Apache-2.0",
@@ -42,7 +42,7 @@
     "prepublishOnly": "npm run typecheck && npm test"
   },
   "devDependencies": {
-    "@types/node": "^26.1.0",
+    "@types/node": "^26.5.0",
     "@vitest/coverage-v8": "^4.1.9",
     "typescript": "^7.0.2",
     "vitest": "^4.1.9"