osv-scanner-mcp 0.4.0 → 0.4.2

package/dist/utils/pomParent.js

@@ -1,21 +1,15 @@
 /**
- * pom.xmlの親POM(`<parent><relativePath>`)が、スキャン許可ルート(OSV_MCP_ALLOWED_ROOT)の外を
- * 参照していないかを検証する。
+ * pom.xmlの親POM(`<parent><relativePath>`)の参照の解釈。連鎖のコピーと検証はscanSnapshot.tsが行う。
  *
  * osv-scanner v2.4.0の実機確認(2026-10-07):
  * - `<relativePath>`の指す親POMを読み、その依存を結果に含める(`--no-resolve`でも同じ)。親の親もたどる
  * - `<relativePath>`省略時はMavenの既定値`../pom.xml`を参照する。ディレクトリを指す場合はその中のpom.xml
  * - `<relativePath/>`(空)はローカルを参照しない。親のGAVが一致しない場合も読まない
  *
- * サブモジュールのスキャンで親POMを読むのは正当な動作のため、境界はプロジェクトディレクトリではなく
- * 許可ルートとする(未設定時は任意のパスをスキャンできる状態のため検証しない)。GAVの一致は判定が
- * 複雑(親から引き継がれる)なため確認せず、許可ルートの外に参照先のファイルがあれば安全側に除外する。
+ * スナップショット方式では、osv-scannerが読めるのはコピーしたファイルだけのため、ここでの解釈が
+ * osv-scannerとずれても範囲外は読まれない(最悪でも親が見つからない)。解釈できない場合の除外は、
+ * 親から引き継ぐ依存を黙って欠落させないためのもの。
  */
-import { readFile, realpath, stat } from "node:fs/promises";
-import path from "node:path";
-import { isInsideDir } from "./projectWalk.js";
-const MAX_POM_BYTES = 10 * 1024 * 1024;
-const MAX_PARENT_DEPTH = 10;
 const DEFAULT_RELATIVE_PATH = "../pom.xml";
 const NAMED_ENTITIES = { lt: "<", gt: ">", amp: "&", apos: "'", quot: '"' };
 /** XMLの文字参照・定義済み実体参照を展開する。未知の実体はundefined */
@@ -144,7 +138,7 @@ export function parentRelativePath(source) {
     return trimmed;
 }
 /** UTF-8として厳密に読む。不正なバイト列・NULを含む場合はnull(Goと同じ解釈を保証できない) */
-function decodePomBytes(bytes) {
+export function decodePomBytes(bytes) {
     let text;
     try {
         text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(bytes);
@@ -154,53 +148,3 @@ function decodePomBytes(bytes) {
     }
     return text.includes("\u0000") ? null : text;
 }
-/** 参照先を実ファイルに解決する。存在しなければnull(osv-scannerもローカルからは読まない) */
-async function resolveParentFile(fromPom, relativePath) {
-    let candidate = path.resolve(path.dirname(fromPom), relativePath);
-    try {
-        if ((await stat(candidate)).isDirectory())
-            candidate = path.join(candidate, "pom.xml");
-        return await realpath(candidate);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * 親POMの連鎖が許可ルートの外を参照していれば、除外理由を返す。問題なければnull。
- * @param pomPath 検出済みのpom.xmlの絶対パス
- * @param allowedRootReal 解決済みの許可ルート。未設定なら検証しない
- */
-export async function pomParentOutsideRoot(pomPath, allowedRootReal) {
-    if (allowedRootReal === undefined)
-        return null;
-    let current = pomPath;
-    for (let depth = 0; depth < MAX_PARENT_DEPTH; depth++) {
-        let bytes;
-        try {
-            if ((await stat(current)).size > MAX_POM_BYTES)
-                return `親POMの確認でサイズ上限を超えるpom.xmlがあります(${path.basename(current)})`;
-            bytes = await readFile(current);
-        }
-        catch {
-            return null; // 読めないファイルはosv-scannerも読めない
-        }
-        const xml = decodePomBytes(bytes);
-        const relativePath = xml === null ? undefined : parentRelativePath(xml);
-        if (relativePath === null || relativePath === "")
-            return null;
-        if (relativePath === undefined) {
-            return ("親POMの指定を確実に解釈できないため(親要素の重複、CDATA・DOCTYPE、プロパティ参照、UTF-8以外の文字コード等)、" +
-                "許可ルート内か確認できずスキャン対象から外しました");
-        }
-        const parentFile = await resolveParentFile(current, relativePath);
-        if (parentFile === null)
-            return null;
-        if (!isInsideDir(allowedRootReal, parentFile)) {
-            return (`親POM(relativePath: ${relativePath})が許可ルート(OSV_MCP_ALLOWED_ROOT)の外を参照しているため、スキャン対象から外しました` +
-                "(親のGAVが一致しなければosv-scannerは読みませんが、境界の外のため確認せず除外します)");
-        }
-        current = parentFile;
-    }
-    return `親POMの連鎖が上限(${MAX_PARENT_DEPTH}段)を超えています`;
-}

package/dist/utils/projectDetector.js

@@ -18,7 +18,6 @@
 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";
 /** ビルド成果物・VCS等、マニフェスト探索でスキップするディレクトリ */
 const SKIPPED_DIRS = new Set([".git", "node_modules", "target", "build", ".idea", ".vscode"]);
@@ -39,27 +38,12 @@ const GRADLE_LOCKFILE_GUIDANCE = "Gradleプロジェクトを検出しました
     "本ツールはlockfile方式のみ対応しています(ビルド実行方式はbuild.gradleの任意コード実行を伴うため非対応)。" +
     "`./gradlew dependencies --write-locks` でlockfileを生成してから再実行してください" +
     "(依存ロックが未設定の場合は build.gradle に dependencyLocking { lockAllConfigurations() } の追加が必要です)";
-/** 親POMが許可ルートの外を参照するpom.xmlを除外して結果を組み立てる。全件除外ならエラー */
-async function buildResult(projectDir, detected, allowedRootReal) {
-    const manifests = [];
-    const skipped = [];
-    for (const manifest of detected) {
-        const reason = path.basename(manifest) === "pom.xml"
-            ? await pomParentOutsideRoot(path.join(projectDir, manifest), allowedRootReal)
-            : null;
-        if (reason !== null)
-            skipped.push({ path: manifest, reason });
-        else
-            manifests.push(manifest);
-    }
-    if (manifests.length === 0) {
-        throw new ScanToolError("path_outside_allowed_root", `スキャンできるマニフェストがありません(${skipped.map((s) => `${s.path}: ${s.reason}`).join(" / ")})`);
-    }
+function buildResult(projectDir, manifests, allowedRootReal) {
     const targets = manifests.map((manifest) => ({
         path: path.join(projectDir, manifest),
         format: path.basename(manifest),
     }));
-    return { projectDir, manifests, targets, skipped };
+    return { projectDir, manifests, targets, allowedRootReal };
 }
 /**
  * 入力パスを検証し、スキャン対象のJavaプロジェクトとして解決する。

package/dist/utils/requirementsFile.js

@@ -16,9 +16,10 @@
  * 外・存在しない・URL・上限超過の取り込み、制約ファイル(`-c`)、解釈できない行は、
  * スキャンされない参照として報告する(黙って無視しない)。
  */
-import { readFile, realpath, stat } from "node:fs/promises";
+import { realpath } from "node:fs/promises";
 import path from "node:path";
 import { isInsideDir } from "./projectWalk.js";
+import { readRegularFile } from "./safeRead.js";
 const MAX_FILE_BYTES = 1024 * 1024;
 const MAX_INCLUDE_DEPTH = 5;
 const MAX_FILES = 50;
@@ -109,7 +110,7 @@ function classifyRequirement(file, line, content, out) {
     }
     out.issues.push({ file, line, name, specifier, kind: "range" });
 }
-async function include(file, line, content, target, projectDir, depth, out) {
+async function include(file, line, content, target, projectDir, depth, out, context) {
     const reference = (reason) => {
         out.references.push({ file, line, text: content, reason });
     };
@@ -133,7 +134,7 @@ async function include(file, line, content, target, projectDir, depth, out) {
         return reference(`取り込みファイルが上限(${MAX_FILES}件)を超えています`);
     let failure;
     try {
-        failure = await analyze(resolved, projectDir, depth + 1, out);
+        failure = await analyze(resolved, projectDir, depth + 1, out, context);
     }
     catch {
         failure = "取り込み先を読み込めません";
@@ -141,19 +142,47 @@ async function include(file, line, content, target, projectDir, depth, out) {
     if (failure !== null)
         reference(failure);
 }
+/** 1回のスキャンで読むrequirements.txt(取り込み先を含む)の合計の上限 */
+const DEFAULT_TOTAL_BYTES = 64 * 1024 * 1024;
+export function createRequirementsReadContext(maxTotalBytes = DEFAULT_TOTAL_BYTES) {
+    return { remainingBytes: maxTotalBytes, texts: new Map() };
+}
+/** 安全に読む(FIFOで止まらず、差し替え・範囲外を検出する)。同じファイルは1回だけ読む */
+async function readText(file, projectDir, context) {
+    const cached = context.texts.get(file);
+    if (cached !== undefined)
+        return { ok: true, text: cached };
+    const budgetLimited = context.remainingBytes < MAX_FILE_BYTES;
+    const result = await readRegularFile(file, {
+        maxBytes: Math.min(MAX_FILE_BYTES, context.remainingBytes),
+        boundary: projectDir,
+    });
+    if (!result.ok) {
+        if (result.failure === "too_large") {
+            return {
+                ok: false,
+                reason: budgetLimited
+                    ? "requirements.txtの解析量の合計が上限を超えたため読みませんでした"
+                    : `サイズが上限(${MAX_FILE_BYTES}バイト)を超えています`,
+            };
+        }
+        return { ok: false, reason: result.message };
+    }
+    context.remainingBytes -= result.bytes.length;
+    const text = result.bytes.toString("utf8");
+    context.texts.set(file, text);
+    return { ok: true, text };
+}
 /** ファイルを解析してoutに追加する。読めない・大きすぎる場合は理由を返す */
-async function analyze(file, projectDir, depth, out) {
+async function analyze(file, projectDir, depth, out, context) {
     out.visited.add(file);
-    const info = await stat(file);
-    if (!info.isFile())
-        return "通常ファイルではありません";
-    if (info.size > MAX_FILE_BYTES)
-        return `サイズが上限(${MAX_FILE_BYTES}バイト)を超えています`;
-    const text = await readFile(file, "utf8");
-    for (const { line, content } of logicalLines(text)) {
+    const read = await readText(file, projectDir, context);
+    if (!read.ok)
+        return read.reason;
+    for (const { line, content } of logicalLines(read.text)) {
         const requirementInclude = INCLUDE_REQUIREMENT.exec(content);
         if (requirementInclude) {
-            await include(file, line, content, requirementInclude[1], projectDir, depth, out);
+            await include(file, line, content, requirementInclude[1], projectDir, depth, out, context);
             continue;
         }
         if (INCLUDE_CONSTRAINT.test(content)) {
@@ -179,11 +208,11 @@ async function analyze(file, projectDir, depth, out) {
  * @param file 検出済みの絶対パス
  * @param projectDir 取り込みを展開する範囲(解決済みの絶対パス)
  */
-export async function analyzeRequirementsFile(file, projectDir) {
+export async function analyzeRequirementsFile(file, projectDir, context = createRequirementsReadContext()) {
     const out = { entries: [], issues: [], references: [], lowerBounds: [], visited: new Set() };
     let reason;
     try {
-        reason = await analyze(await realpath(file), projectDir, 0, out);
+        reason = await analyze(await realpath(file), projectDir, 0, out, context);
     }
     catch {
         reason = "読み込めません";

package/dist/utils/safeRead.js

@@ -0,0 +1,150 @@
+/**
+ * スキャン対象ファイルの安全な読み込み(検査と読み込みの不一致を起こさないための共通部品)。
+ *
+ * - `O_NOFOLLOW`で開き、末尾がシンボリックリンクに差し替えられたファイルを読まない
+ * - `O_NONBLOCK`で開き、名前付きパイプ(FIFO)等で処理が止まらないようにする。開いた実体を
+ *   `fstat`し、通常のファイル以外は読まない
+ * - サイズの上限付きで読む
+ * - 読み終えた後、パスを解決し直して境界の内側にあることと、開いた実体と同じファイル
+ *   (デバイス番号・inodeが一致)であることを確認する。途中のディレクトリをシンボリックリンクに
+ *   差し替えて範囲外を読ませ、確認前に戻す、といった差し替えを検出する
+ *
+ * 呼び出し側は読んだ内容(またはそのコピー)だけを使い、元のパスを他のプロセスに渡さない。
+ * (ハードリンクはパスとしては境界の内側にあるため区別しない)
+ */
+import { constants } from "node:fs";
+import { open, realpath, rm, stat } from "node:fs/promises";
+import { isInsideDir } from "./projectWalk.js";
+const OPEN_FLAGS = constants.O_RDONLY | (constants.O_NONBLOCK ?? 0) | (constants.O_NOFOLLOW ?? 0);
+const MESSAGES = {
+    not_found: "ファイルを開けません",
+    not_regular: "通常のファイルではありません(名前付きパイプ・デバイス等)",
+    too_large: "サイズが上限を超えています",
+    outside: "スキャン範囲の外のファイルです",
+    changed: "検査中にファイルが差し替えられました",
+};
+function failure(kind) {
+    return { ok: false, failure: kind, message: MESSAGES[kind] };
+}
+/**
+ * 読み終えた後の確認: パスを解決し直し、境界の内側で、開いた実体と同じファイルか。
+ * 問題が無ければnull、あれば失敗の種類を返す。
+ */
+export async function verifyOpenedFile(filePath, opened, boundary) {
+    let resolved;
+    let current;
+    try {
+        resolved = await realpath(filePath);
+        current = await stat(resolved);
+    }
+    catch {
+        return "changed";
+    }
+    if (current.dev !== opened.dev || current.ino !== opened.ino)
+        return "changed";
+    if (boundary !== undefined && !isInsideDir(boundary, resolved))
+        return "outside";
+    return null;
+}
+/**
+ * 通常のファイルを上限付きで安全にdestへコピーする(大きなJAR/WAR向けに全体をメモリに載せない)。
+ * destは新規作成(既存なら失敗)・所有者のみ読み書き可。失敗時はdestを削除する。
+ * 成功時はコピーしたバイト数を返す。
+ */
+export async function copyRegularFile(filePath, dest, options) {
+    let source;
+    try {
+        source = await open(filePath, OPEN_FLAGS);
+    }
+    catch {
+        return failure("not_found");
+    }
+    let total = 0;
+    let result = null;
+    try {
+        const info = await source.stat();
+        if (!info.isFile())
+            result = "not_regular";
+        else if (info.size > options.maxBytes)
+            result = "too_large";
+        else {
+            const target = await open(dest, "wx", 0o600);
+            try {
+                const chunk = Buffer.alloc(1024 * 1024);
+                while (true) {
+                    const { bytesRead } = await source.read(chunk, 0, chunk.length, null);
+                    if (bytesRead === 0)
+                        break;
+                    total += bytesRead;
+                    if (total > options.maxBytes) {
+                        result = "too_large";
+                        break;
+                    }
+                    // writeは要求より少ないバイト数で戻りうるため、チャンクを書き切るまで繰り返す
+                    for (let written = 0; written < bytesRead;) {
+                        const { bytesWritten } = await target.write(chunk, written, bytesRead - written);
+                        if (bytesWritten <= 0)
+                            throw new Error("short write");
+                        written += bytesWritten;
+                    }
+                }
+            }
+            finally {
+                await target.close();
+            }
+            if (result === null)
+                result = await verifyOpenedFile(filePath, info, options.boundary);
+        }
+    }
+    catch {
+        result = "not_found";
+    }
+    finally {
+        await source.close();
+    }
+    if (result !== null) {
+        await rm(dest, { force: true });
+        return failure(result);
+    }
+    return { ok: true, bytes: total };
+}
+/** 通常のファイルを上限付きで安全に読む */
+export async function readRegularFile(filePath, options) {
+    let handle;
+    try {
+        handle = await open(filePath, OPEN_FLAGS);
+    }
+    catch {
+        return failure("not_found");
+    }
+    let info;
+    const chunks = [];
+    let total = 0;
+    try {
+        info = await handle.stat();
+        if (!info.isFile())
+            return failure("not_regular");
+        if (info.size > options.maxBytes)
+            return failure("too_large");
+        const chunk = Buffer.alloc(Math.min(1024 * 1024, options.maxBytes + 1));
+        while (true) {
+            const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, options.maxBytes - total + 1), null);
+            if (bytesRead === 0)
+                break;
+            total += bytesRead;
+            if (total > options.maxBytes)
+                return failure("too_large");
+            chunks.push(Buffer.from(chunk.subarray(0, bytesRead)));
+        }
+    }
+    catch {
+        return failure("not_found");
+    }
+    finally {
+        await handle.close();
+    }
+    const problem = await verifyOpenedFile(filePath, info, options.boundary);
+    if (problem !== null)
+        return failure(problem);
+    return { ok: true, bytes: Buffer.concat(chunks, total) };
+}

package/dist/utils/sbomInput.js

@@ -3,6 +3,7 @@ import { constants } from "node:fs";
 import { open, realpath } from "node:fs/promises";
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
+import { verifyOpenedFile } from "./safeRead.js";
 import { asRecord } from "./unknownJson.js";
 const DEFAULT_MAX_INPUT_BYTES = 16 * 1024 * 1024;
 const CYCLONEDX_VERSIONS = new Set(["1.4", "1.5", "1.6"]);
@@ -33,8 +34,9 @@ export async function loadSbom(inputPath, options = {}) {
     try {
         // Nonblocking open avoids hanging on FIFOs. Refuse a leaf replaced by a symlink.
         const file = await open(sourcePath, constants.O_RDONLY | constants.O_NONBLOCK | (constants.O_NOFOLLOW ?? 0));
+        let info;
         try {
-            const info = await file.stat();
+            info = await file.stat();
             if (!info.isFile())
                 throw new ScanToolError("sbom_not_found", "SBOM input must be a regular file");
             if (info.size > maxBytes)
@@ -56,6 +58,13 @@ export async function loadSbom(inputPath, options = {}) {
         finally {
             await file.close();
         }
+        // 読んだ後に、差し替え(途中のディレクトリのシンボリックリンク化等)と境界を確認する
+        const allowedRootReal = options.allowedRoot !== undefined ? await realpath(options.allowedRoot) : undefined;
+        const problem = await verifyOpenedFile(sourcePath, info, allowedRootReal);
+        if (problem === "outside")
+            throw new ScanToolError("path_outside_allowed_root", "SBOM path is outside the allowed root");
+        if (problem !== null)
+            throw new ScanToolError("sbom_not_found", "The SBOM file was replaced while it was being read");
     }
     catch (error) {
         if (error instanceof ScanToolError)

package/dist/utils/scanSnapshot.js

@@ -0,0 +1,209 @@
+/**
+ * スキャン対象のスナップショット: osv-scannerには元のファイルを渡さず、安全に1回だけ読んだ内容を
+ * 専用の一時ディレクトリ(所有者のみアクセス可、終了時に削除)へコピーしてスキャンする。
+ *
+ * - 検査(境界・親POMの検証)はコピーの内容に対して行うため、検査とosv-scannerの読み込みの間に
+ *   元のファイルを差し替えても結果に影響しない
+ * - 親POMは元の配置をスナップショット内に再現してコピーする。osv-scannerが相対パスで親をたどっても、
+ *   見つかるのは検証してコピーしたファイルだけになる(解析が多少ずれても範囲外は読まれず、
+ *   最悪でも親が見つからないだけ)
+ * - `..`を重ねた参照でスナップショットの外(本物のファイルシステム)に出る親POMは除外する
+ * - コピーの合計サイズに上限を設ける
+ */
+import { mkdir, mkdtemp, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { ScanToolError } from "../errors.js";
+import { decodePomBytes, parentRelativePath } from "./pomParent.js";
+import { isInsideDir } from "./projectWalk.js";
+import { copyRegularFile } from "./safeRead.js";
+const DEFAULT_MAX_TOTAL_BYTES = 2 * 1024 * 1024 * 1024;
+const MAX_POM_BYTES = 10 * 1024 * 1024;
+const MAX_PARENT_DEPTH = 10;
+export class ScanSnapshot {
+    dir;
+    maxTotalBytes;
+    copied = new Map();
+    parentCache = new Map();
+    /** 再現した配置のルートごとのディレクトリ → 元のルート("/"等) */
+    mirroredRoots = new Map();
+    used = 0;
+    generated = 0;
+    constructor(dir, maxTotalBytes) {
+        this.dir = dir;
+        this.maxTotalBytes = maxTotalBytes;
+    }
+    static async create(maxTotalBytes = DEFAULT_MAX_TOTAL_BYTES) {
+        const dir = await mkdtemp(path.join(await realpath(os.tmpdir()), "osv-mcp-snap-"));
+        return new ScanSnapshot(dir, maxTotalBytes);
+    }
+    /** 再現した配置のルート(実際のファイルシステムの"/"に相当) */
+    get treeRoot() {
+        return path.join(this.dir, "tree");
+    }
+    /** 元の絶対パスに対応する、スナップショット内のパス */
+    mirror(absolute) {
+        const { root } = path.parse(absolute);
+        const mirroredRoot = path.join(this.treeRoot, root.replace(/[^A-Za-z0-9]/g, "_"));
+        this.mirroredRoots.set(mirroredRoot, root);
+        return path.join(mirroredRoot, path.relative(root, absolute));
+    }
+    /**
+     * スキャナーのメッセージ(stderr等)に含まれるコピーのパスを元のパスに戻す。
+     * 生成したコピー(requirements.txt)など元のファイルが無いものは一時ディレクトリと分かる表記にする
+     */
+    restorePaths(text) {
+        let restored = text;
+        for (const [mirroredRoot, root] of this.mirroredRoots)
+            restored = restored.split(mirroredRoot + path.sep).join(root);
+        return restored.split(this.dir).join("<一時コピー>");
+    }
+    /** スキャナーのエラーに一時ディレクトリのパスを出さない(応答のパスは常に元のファイルを指す) */
+    async guard(scan) {
+        try {
+            return await scan();
+        }
+        catch (error) {
+            if (!(error instanceof ScanToolError))
+                throw error;
+            throw new ScanToolError(error.kind, this.restorePaths(error.message), error.detail === undefined ? undefined : this.restorePaths(error.detail));
+        }
+    }
+    /** 元のファイルを安全にコピーする。同じファイルは1回だけコピーする */
+    async copy(absolute, boundary, maxBytes = Infinity) {
+        const existing = this.copied.get(absolute);
+        if (existing !== undefined)
+            return { ok: true, path: existing };
+        const remaining = this.maxTotalBytes - this.used;
+        const dest = this.mirror(absolute);
+        await mkdir(path.dirname(dest), { recursive: true, mode: 0o700 });
+        const result = await copyRegularFile(absolute, dest, { maxBytes: Math.min(maxBytes, remaining), boundary });
+        if (!result.ok) {
+            if (result.failure === "too_large" && remaining < maxBytes) {
+                throw new ScanToolError("scan_input_too_large", `スキャン対象ファイルの合計サイズが上限(${this.maxTotalBytes}バイト)を超えるため、スキャンを中止しました。対象を絞って再実行してください`);
+            }
+            return result;
+        }
+        this.used += result.bytes;
+        this.copied.set(absolute, dest);
+        return { ok: true, path: dest };
+    }
+    /** 本サーバーが生成した内容(requirements.txtの正規化コピー等)を書く */
+    async writeGenerated(content) {
+        const dir = path.join(this.dir, "generated");
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+        const file = path.join(dir, `${this.generated++}.txt`);
+        await writeFile(file, content, { mode: 0o600, flag: "wx" });
+        return file;
+    }
+    /** コピー済みのpom.xmlの親参照(同じファイルは1回だけ解析する) */
+    async parentOf(copyPath) {
+        if (this.parentCache.has(copyPath))
+            return this.parentCache.get(copyPath);
+        const xml = decodePomBytes(await readFile(copyPath));
+        const relativePath = xml === null ? undefined : parentRelativePath(xml);
+        this.parentCache.set(copyPath, relativePath);
+        return relativePath;
+    }
+    async cleanup() {
+        await rm(this.dir, { recursive: true, force: true });
+    }
+}
+const UNPARSEABLE = "親POMの指定を確実に解釈できないため(親要素の重複、CDATA・DOCTYPE、プロパティ参照、UTF-8以外の文字コード等)、" +
+    "許可ルート内か確認できずスキャン対象から外しました";
+/**
+ * pom.xmlと親POMの連鎖をスナップショットへコピーする。
+ * 許可ルート設定時、連鎖が許可ルートの外・スナップショットの外を参照するか、解釈できない場合は除外理由を返す。
+ * 存在する親POMを再現できなかった場合(サイズ超過・通常のファイルでない等)はスキャンを続けるが、
+ * 親から継承する依存が欠ける可能性があるためincompleteに理由を返す(黙って成功扱いにしない)。
+ */
+async function snapshotPom(snapshot, pomPath, context) {
+    const copied = await snapshot.copy(pomPath, context.projectDir, MAX_POM_BYTES);
+    if (!copied.ok)
+        return { ok: false, reason: copied.message, kind: "unreadable" };
+    const first = { ok: true, path: copied.path };
+    const partial = (reason) => ({ ...first, incomplete: reason });
+    const restricted = context.allowedRootReal !== undefined;
+    let current = pomPath;
+    let currentCopy = first.path;
+    for (let depth = 0; depth < MAX_PARENT_DEPTH; depth++) {
+        const relativePath = await snapshot.parentOf(currentCopy);
+        if (relativePath === null || relativePath === "")
+            return first;
+        if (relativePath === undefined) {
+            return restricted
+                ? { ok: false, reason: UNPARSEABLE, kind: "unreadable" }
+                : partial("親POMの指定を確実に解釈できないため、親POMを含めずにスキャンしました。親から継承する依存が結果に含まれない可能性があります");
+        }
+        // Goのfilepath.Joinと同じ規則で結合する(絶対パスも連結し、..はルートで止まる)
+        const inCopy = path.join(path.dirname(currentCopy), relativePath);
+        if (!isInsideDir(snapshot.treeRoot, inCopy)) {
+            // ..を重ねるとスナップショットの外(本物のファイルシステム)に届くため、コピーではなく元のファイルが読まれる
+            return restricted
+                ? { ok: false, reason: `親POM(relativePath: ${relativePath})の参照がスキャン範囲の外に出るため、スキャン対象から外しました`, kind: "outside_allowed_root" }
+                : first;
+        }
+        let candidate = path.join(path.dirname(current), relativePath);
+        try {
+            if ((await stat(candidate)).isDirectory())
+                candidate = path.join(candidate, "pom.xml");
+        }
+        catch (error) {
+            // 参照先が無い: 元の配置でもosv-scannerは親を読まないため、欠落ではない
+            const code = error.code;
+            if (code === "ENOENT" || code === "ENOTDIR")
+                return first;
+            return partial(`親POM(relativePath: ${relativePath})を確認できないため、親POMを含めずにスキャンしました。親から継承する依存が結果に含まれない可能性があります`);
+        }
+        const parent = await snapshot.copy(candidate, context.allowedRootReal, MAX_POM_BYTES);
+        if (!parent.ok) {
+            if (parent.failure === "outside") {
+                return {
+                    ok: false,
+                    reason: `親POM(relativePath: ${relativePath})が許可ルート(OSV_MCP_ALLOWED_ROOT)の外を参照しているため、スキャン対象から外しました` +
+                        "(親のGAVが一致しなければosv-scannerは読みませんが、境界の外のため確認せず除外します)",
+                    kind: "outside_allowed_root",
+                };
+            }
+            if (parent.failure === "changed")
+                return { ok: false, reason: `親POMの${parent.message}`, kind: "unreadable" };
+            // 読めない・通常のファイルでない・サイズ超過等: コピーしないため、osv-scannerも読まない
+            return partial(`親POM(relativePath: ${relativePath})を読めないため(${parent.message})、親POMを含めずにスキャンしました。` +
+                "親から継承する依存が結果に含まれない可能性があります(親のGAVが一致しない場合はもともと読まれません)");
+        }
+        current = candidate;
+        currentCopy = parent.path;
+    }
+    return restricted
+        ? { ok: false, reason: `親POMの連鎖が上限(${MAX_PARENT_DEPTH}段)を超えています`, kind: "unreadable" }
+        : partial(`親POMの連鎖が上限(${MAX_PARENT_DEPTH}段)を超えるため、それより上の親POMを含めずにスキャンしました`);
+}
+/**
+ * 検出済みのマニフェストをスナップショットへコピーし、osv-scannerに渡す対象(コピー)を返す。
+ * コピーできない・除外すべきものはskippedに、親POMを再現できずスキャンしたものはincompleteに理由付きで返す。
+ */
+export async function snapshotManifests(snapshot, targets, context) {
+    const copies = [];
+    const skipped = [];
+    const incomplete = [];
+    for (const target of targets) {
+        if (target.format === "pom.xml") {
+            const result = await snapshotPom(snapshot, target.path, context);
+            if (result.ok) {
+                copies.push({ path: result.path, format: target.format });
+                if (result.incomplete !== undefined)
+                    incomplete.push({ path: target.path, reason: result.incomplete });
+            }
+            else {
+                skipped.push({ path: target.path, reason: result.reason, kind: result.kind });
+            }
+            continue;
+        }
+        const result = await snapshot.copy(target.path, context.projectDir);
+        if (result.ok)
+            copies.push({ path: result.path, format: target.format });
+        else
+            skipped.push({ path: target.path, reason: result.message, kind: "unreadable" });
+    }
+    return { targets: copies, skipped, incomplete };
+}