osv-scanner-mcp 0.6.0 → 0.7.1

package/README.md

@@ -200,7 +200,10 @@ api.osv.dev と deps.dev はどちらも Google が運営するサービスで
   "vulnerable_package_count": 2,
   "vulnerability_count": 4,
   "severity_breakdown": { "critical": 0, "high": 2, "medium": 2, "low": 0, "unknown": 0 },
-  "packages": [{ "name": "minimist", "version": "1.2.5", "ecosystem": "npm", "dependency_groups": ["dev"], "vulnerabilities": [] }]
+  "packages": [
+    { "name": "minimist", "version": "1.2.5", "ecosystem": "npm", "dependency_groups": ["dev"], "dependency_relation": "direct", "declared_in": ["package.json"], "vulnerabilities": [] },
+    { "name": "qs", "version": "6.7.0", "ecosystem": "npm", "dependency_relation": "transitive", "introduced_by": ["express"], "vulnerabilities": [] }
+  ]
 }
 ```
 
@@ -211,6 +214,11 @@ api.osv.dev と deps.dev はどちらも Google が運営するサービスで
   - `skipped_files`: スキャン対象から外したファイルと理由(requirements.txt自体が読めない・1MiBを超える場合、`pom.xml` の親POMが許可ルートの外を参照する場合)。親POMを読めず、親POMを含めずにスキャンした `pom.xml` もここに理由付きで示します([親POMの扱い](#親pomの扱い)を参照)
   - 各一覧は200件までで、超えた分の件数を `omitted_items` に返します
 - `ecosystem_breakdown` は、脆弱性0件のエコシステムも含めて「スキャンした」ことを示します
+- `dependency_relation` は直接依存(`direct`)か推移的依存(`transitive`)かを示します。OSV-Scannerの出力にはこの区別がないため、本サーバーがスキャンしたファイルのコピーを解析して判定します:
+  - `package-lock.json`(v2以降): ルートとworkspaceのpackage.jsonの依存を、Nodeの解決規則(入れ子の `node_modules` から上位へ)で解決したものが直接依存、そこからたどれるものが推移的依存です。直接依存には宣言しているpackage.jsonを `declared_in` に、推移的依存にはそれを要求している直接依存の名前を `introduced_by`(最大10件、超えた分は `introduced_by_omitted`)に示します。直接依存でもあり他の依存からも要求される版は `direct` とし、`introduced_by` も付けます
+  - `go.mod`: `// indirect` の無い `require` が直接依存です。`replace` で置き換えているモジュールには `replaced_in_go_mod: true` を付けます(OSV-Scannerは置換先のパスと版で報告します)
+  - `requirements.txt`: ファイルに書かれた依存が直接依存、deps.devで解決された依存が推移的依存です
+  - 上記以外の形式(`pom.xml`、`gradle.lockfile`、`yarn.lock`、`pnpm-lock.yaml`、`bun.lock`、`poetry.lock`、`uv.lock`、`Pipfile.lock`、`pdm.lock`)と、lockfileVersion 1・どこからも要求されていないエントリは `unknown` です。複数のlockfileで判定が異なる場合は `mixed` です
 - `dependency_groups` はOSV-Scannerが付けた依存グループ(例: `dev`)の生の値です。lockfileの形式によって欠落・不正確なため(pnpmでは付かず、pdmでは `optional` になる等)、参考情報として扱ってください
 - 修正版の推奨(`suggest_fix`)はJava・JavaScript・Python・Goに対応しています
 
@@ -318,7 +326,7 @@ OSV-Scanner 2.4.0の `java/archive` プラグインを使用し、ネストJAR
 - **対応形式**: UTF-8 JSONのCycloneDX 1.4 / 1.5 / 1.6、SPDX 2.2 / 2.3。XML、SPDX tag-value、SPDX 3は未対応です。
 - **入力**: 16MiB以下のローカル通常ファイルの絶対パス。ファイル名は任意で、内容から形式を判別します。CycloneDXは`components`、SPDXは`packages`配列が必要です。形式・主要構造の確認であり、仕様全体のJSON Schema検証ではありません。
 - **識別情報**: CycloneDXの`components[].purl`、SPDXの`packages[].externalRefs`にバージョン付きPackage URLを含めてください。例: `pkg:maven/org.apache.logging.log4j/log4j-core@2.14.1`。詳細は[OSV-Scanner公式ドキュメント](https://github.com/google/osv-scanner/blob/main/docs/scan-source.md)を参照してください。
-- **安全な読み込み**: 許可ルートと読み込み中のサイズ上限を確認し、権限制限付きの一時コピーだけをスキャンします。元ファイルは変更せず、一時コピーは成功・失敗ともに削除します。
+- **安全な読み込み**: 許可ルートと読み込み中のサイズ上限を確認し、権限制限付きの一時コピーだけをスキャンします。元ファイルは変更せず、一時コピーは成功・失敗ともに削除します。スキャン中にサーバーが終了した場合(SIGTERM/SIGINT/SIGHUP、MCPクライアントがstdinを閉じた場合)も、一時コピーを削除し実行中のOSV-Scannerを止めてから終了します。
 
 出力の先頭に`coverage`を返します。
 
@@ -378,6 +386,7 @@ npm・Go・PyPIの「同じ系統」は、npmの `^`(キャレット)が互換
 - 推奨時は `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` です。修正版の記載はあるがバージョンとして解釈できないCVE(SemVerでない `13.0` 等)は `tier: "unparseable_fix"` とし、修正版が無いとは扱わず修正対象に残すため、推奨は保留(`no_verified_candidate`)になります。
 - npm・Go・PyPIの提案には更新方法の `update_hint` を付けます。PyPIでは、requirements.txtやpyproject.toml・Pipfileの指定を更新してlockfileを再生成し、推移的依存はpipの制約ファイル(`-c`)やuv・Poetryの上書き設定で版を指定します。推移的依存の場合、npmでは要求している直接依存の更新か、ルートの `package.json` の `overrides`(ルートのプロジェクトでのみ有効)で版を指定します。Goでは `go get <module>@<version>` で更新できます。Goのv2以上のメジャーは別のモジュールパス(`/v2` 等)としてOSV上も別パッケージになるため、新しいメジャー系列の修正版は候補に含まれません。現在の版が疑似バージョン(タグのないコミット)の場合は `upgrade_note` に示します。
+- 各提案には `scan_project` と同じ `dependency_relation`(と `introduced_by` / `declared_in` / `replaced_in_go_mod`)を付け、`update_hint` を直接/推移的依存の別に応じて具体化します(npmの推移的依存なら `introduced_by` の直接依存の更新と `overrides`、Goの `replace` ならreplaceの版の更新、等)。`unknown` / `mixed` の場合は両方の場合を案内します。
 - requirements.txtの `>=X` / `~=X` の行は、OSV-Scannerが下限Xを使用中の版とみなしてスキャンしています。この依存の提案には `version_is_lower_bound: true` を付け、推奨は「下限を推奨版以上に引き上げる」意味であること(実際にインストールされる版とは異なりうること)を `upgrade_note` に示します。
 - 推奨に未対応のエコシステム(SBOM由来のRubyGems等)は `verification: "unsupported_ecosystem"`、現在の版をバージョンとして解釈できない場合(npmのgit・ローカルパス依存等)は `verification: "unparseable_version"` を返し、どちらもCVEごとの `tier: "unsupported"` として `unfixed` には数えません(修正版の有無は判定していないため。修正版は `scan_project` の `fixed_versions` や `explain_vulnerability` で確認できます)。
 - 応答の `coverage` は `scan_project` と同じです。lockfileの無いマニフェストや外したファイルがあれば `complete: false` になり、それらの依存は提案に含まれません。v0.4.2以前の `skipped_manifests` / `scope_warning` は `coverage.skipped_files` / `coverage.warning` に統合しました。
@@ -437,7 +446,7 @@ npm・Go・PyPIの「同じ系統」は、npmの `^`(キャレット)が互換
 
 - **サプライチェーン対策**: バイナリの自動ダウンロードは公式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`)
+- **スナップショット方式(検査と読み込みの不一致の防止)**: OSV-Scannerには元のファイルを一切渡しません。lockfile・`pom.xml`(親POMの連鎖を含む)・JAR/WARは、本サーバーが安全に1回だけ読んだ内容を専用の一時ディレクトリ(所有者のみアクセス可、終了時に削除)へコピーしてスキャンし、検査もそのコピーに対して行います。検査の後で元のファイルやディレクトリを差し替えても結果には影響しません。親POMは元の配置を一時ディレクトリ内に再現してコピーするため、OSV-Scannerが相対パスで親をたどっても、見つかるのは検証してコピーしたファイルだけです(`..` を重ねて一時ディレクトリの外に届く参照は除外)。読み込みは末尾のシンボリックリンクをたどらず、名前付きパイプ等の通常のファイル以外は読まず(処理が止まらない)、読み終えた後にパスを解決し直して境界の内側かつ開いた実体と同じファイルかを確認します。コピーの合計サイズは2GiBまでです(超えると `scan_input_too_large`)。SIGKILL等の捕捉できない終了で残った一時ディレクトリは、次回以降の起動時に削除します(名前が本サーバーの接頭辞に完全一致し、自分が所有する実体のディレクトリで、最終更新から24時間以上経過したものだけ。シンボリックリンクはたどりません)
 - **パストラバーサル対策**: 入力パスは `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)を設け、並列リクエストによるプロセスの無制限起動を防ぎます。本サーバー自身の解析も、同じファイルは1回だけ読んで結果を使い回し(workspaceの収録確認でのlockfile、requirements.txtの共通の取り込み先、親POM)、読む量の合計に上限を設けます
 - **fail-closedな運用モード**: `OSV_MCP_REQUIRE_ALLOWED_ROOT=1` で、スキャン許可ルート未設定時にサーバーの起動自体を拒否できます
@@ -467,7 +476,7 @@ npm run build             # dist/ へビルド
 - [x] `scan_project` ツール: Java / JavaScript / Python / Go のlockfileをまとめてスキャン
 - [x] `suggest_fix` のJavaScript / Go対応(semver)
 - [x] `suggest_fix` のPython対応(PEP 440)
-- [ ] 直接/推移的依存の区別
+- [x] 直接/推移的依存の区別(npm・Go・requirements.txt)
 
 ## ライセンス
 

package/dist/index.js

@@ -20,6 +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 { installShutdownHandlers, removeStaleTempDirs } from "./utils/processCleanup.js";
 import { ALLOWED_ROOT_ENV, allowedRootFromEnv, allowedRootStartupError, allowedRootStartupWarning, } from "./utils/startupConfig.js";
 export { ALLOWED_ROOT_ENV };
 // fail-closed: 運用モードで許可ルートが未設定なら、ツールを一切公開せず終了する
@@ -36,7 +37,7 @@ if (startupWarning !== null) {
 // NOTE: リリース時はpackage.jsonのversionと同じ値に更新すること
 const server = new McpServer({
     name: "osv-scanner-mcp",
-    version: "0.6.0",
+    version: "0.7.1",
 });
 server.registerTool("scan_project", {
     title: "プロジェクトの依存の脆弱性スキャン(Java / JavaScript / Python / Go)",
@@ -45,6 +46,7 @@ server.registerTool("scan_project", {
         "Python(poetry.lock / uv.lock / Pipfile.lock / pdm.lock / requirements.txt)、Go(go.mod)。" +
         "パッケージマネージャーやビルドは実行しない。" +
         "応答先頭のcoverageを必ず確認すること: lockfileが無いマニフェスト、バージョン未固定のrequirements行、スキャン対象から外したファイルを示す。" +
+        "各パッケージのdependency_relationは直接依存(direct)か推移的依存(transitive)か(package-lock.json・go.mod・requirements.txtで判定。それ以外はunknown)。" +
         "coverage.complete=falseの場合は、検出0件でも安全とは判断しないこと。修正版の推奨(suggest_fix)はJava・JavaScript・Python・Goに対応。",
     inputSchema: {
         project_path: z
@@ -72,7 +74,7 @@ server.registerTool("suggest_fix", {
         "推奨はJava(Maven / Gradle)・JavaScript(npm)・Python(PyPI)・Goに対応。" +
         "現在のバージョンに最も近いリリース系統の修正版を優先する3段階フォールバック" +
         "(same_minor: 同一系統内 → major_internal: 同一メジャー内 → cross_major: メジャーアップグレード)で選定し、" +
-        "推奨バージョン・アップグレード距離(upgrade_tier)・CVEごとの修正版を返す。npm・Go・PyPIでは0.x系のマイナー更新もcross_major(破壊的変更の可能性)。requirements.txtの下限(>=)でスキャンした依存はversion_is_lower_boundを付け、推奨は下限の引き上げを意味する。" +
+        "推奨バージョン・アップグレード距離(upgrade_tier)・CVEごとの修正版を返す。npm・Go・PyPIでは0.x系のマイナー更新もcross_major(破壊的変更の可能性)。requirements.txtの下限(>=)でスキャンした依存はversion_is_lower_boundを付け、推奨は下限の引き上げを意味する。直接/推移的依存の別(dependency_relation、npmはintroduced_by・declared_in)に応じて更新方法(update_hint)を示す。" +
         "候補を全修正対象CVEの影響範囲と照合し、情報不足の場合は推奨を保留する。プレリリース版は正式版で解消できない場合だけ推奨し、recommended_is_prereleaseを付ける。" +
         "現在より新しい修正版候補のないCVEはunfixedとして別表示し、推奨先での判定も返す。" +
         "応答のcoverageを必ず確認すること(complete=falseなら提案に含まれない依存がある)。" +
@@ -115,6 +117,13 @@ server.registerTool("scan_sbom", {
         sbom_path: z.string().min(1).describe("CycloneDX/SPDX JSON SBOMファイルの絶対パス"),
     },
 }, async ({ sbom_path }) => handleScanSbom({ sbom_path }, { allowedRoot: allowedRootFromEnv() }));
+// シグナル・stdinの終了時に一時ディレクトリと実行中のosv-scannerを片付ける(接続前に登録する)
+installShutdownHandlers();
+// 前回の異常終了で残った一時ディレクトリの掃除。起動を遅らせないよう待たない
+removeStaleTempDirs().then((removed) => {
+    if (removed > 0)
+        console.error(`osv-scanner-mcp: 前回の終了時に残った一時ディレクトリを${removed}件削除しました`);
+}, () => { });
 const transport = new StdioServerTransport();
 await server.connect(transport);
 // stdoutはMCPプロトコル専用のため、起動ログはstderrへ

package/dist/osv/runner.js

@@ -10,6 +10,7 @@
  *   requirements.txt等も読み、その`-r ../x.txt`の取り込みでスキャン範囲の外のファイルを読むため
  * - SBOMは検証・サイズ制限済みの専用一時コピー1つだけを渡す
  * - タイムアウトと出力サイズ上限を設ける(ハング・巨大出力によるDoS対策)
+ * - サーバーの終了時に実行中のプロセスを残さない(processCleanup.tsに登録し、終了時にSIGKILL)
  *
  * 終了コード(2.4.0で実機確認):
  *   0 = スキャン成功・脆弱性なし / 1 = スキャン成功・脆弱性あり / 128 = 対象パッケージなし
@@ -18,6 +19,7 @@ import { spawn } from "node:child_process";
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
 import { isManifestFormat } from "../utils/manifestFormats.js";
+import { trackChildProcess } from "../utils/processCleanup.js";
 import { resolveOsvScannerBinary } from "./binaryManager.js";
 import { parseOsvScanOutput } from "./scanReport.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -96,6 +98,7 @@ function execOsvScanner(binaryPath, targetPaths, timeoutMs, maxOutputBytes, scan
             shell: false,
             stdio: ["ignore", "pipe", "pipe"],
         });
+        trackChildProcess(child);
         const stdoutChunks = [];
         const stderrChunks = [];
         let stdoutBytes = 0;

package/dist/osv/scanReport.js

@@ -93,6 +93,16 @@ function extractFixedVersions(vulnDetails, packageName, ecosystem) {
     }
     return sortVersions(versions, ecosystem);
 }
+/**
+ * パッケージごとのスキャン元ファイル(osv-scannerの`results[].source.path`)。
+ * 応答のJSONには出さない(既存の応答を変えない)ため、パッケージのオブジェクトをキーに別に持つ。
+ * 直接/推移的依存の判定(dependencyRelations.ts)が、どのlockfileの依存かを知るために使う
+ */
+const packageSourceMap = new WeakMap();
+/** parseOsvScanOutputが返したパッケージのスキャン元ファイル。それ以外のオブジェクトは空 */
+export function packageSources(pkg) {
+    return packageSourceMap.get(pkg) ?? [];
+}
 /**
  * OSV-Scannerの`--format json`出力を`scan_java_project`のレポートに変換する。
  *
@@ -123,9 +133,11 @@ export function parseOsvScanOutput(raw) {
             const key = `${ecosystem}:${name}@${version}`;
             let entry = packageMap.get(key);
             if (!entry) {
-                entry = { name, version, ecosystem, groups: new Set(), vulns: new Map() };
+                entry = { name, version, ecosystem, groups: new Set(), sources: new Set(), vulns: new Map() };
                 packageMap.set(key, entry);
             }
+            if (sourcePath !== null)
+                entry.sources.add(sourcePath);
             for (const group of asStrings(pkgObj.dependency_groups))
                 entry.groups.add(group);
             const details = asArray(pkgObj.vulnerabilities);
@@ -177,13 +189,15 @@ function buildReport(sourceFiles, packageMap) {
             severityBreakdown[vuln.severity]++;
             vulnerabilityCount++;
         }
-        return {
+        const pkg = {
             name: entry.name,
             version: entry.version,
             ecosystem: entry.ecosystem,
             ...(entry.groups.size > 0 ? { dependency_groups: [...entry.groups].sort() } : {}),
             vulnerabilities,
         };
+        packageSourceMap.set(pkg, [...entry.sources]);
+        return pkg;
     })
         .sort((a, b) => maxScore(b.vulnerabilities) - maxScore(a.vulnerabilities) || cmpId(a.name, b.name));
     return {

package/dist/osv/suggestFix.js

@@ -29,10 +29,62 @@ const UPDATE_HINTS = {
 };
 /** Goの疑似バージョン(タグのないコミット): 末尾がタイムスタンプ14桁-コミットハッシュ12桁 */
 const GO_PSEUDO_VERSION = /(?:^|[.-])\d{14}-[0-9a-f]{12}(?:\+|$)/;
-function hintFields(ecosystem) {
-    const hint = UPDATE_HINTS[ecosystem];
+const GO_MAJOR_NOTE = "Goではv2以上のメジャーは別のモジュールパス(/v2等)として別パッケージ扱いのため、新しいメジャー系列の修正版はここに含まれません";
+/**
+ * 推奨版への更新方法。直接/推移的依存の別が分かれば具体化し、分からなければ(unknown・mixed)両方を案内する
+ */
+function updateHint(pkg) {
+    const relation = pkg.dependency_relation;
+    const by = pkg.introduced_by?.join("、");
+    switch (pkg.ecosystem) {
+        case "npm":
+            if (relation === "direct") {
+                return `直接依存です。${pkg.declared_in?.join("、") ?? "package.json"}の指定を更新します` +
+                    (by ? `。${by}からも推移的に要求されているため、それらの更新が必要な場合もあります` : "");
+            }
+            if (relation === "transitive") {
+                return `推移的依存です。${by ? `要求している直接依存(${by})` : "要求している直接依存"}を、推奨版以上を要求する版に更新します。` +
+                    "直接依存の更新で直らない場合は、ルートのpackage.jsonのoverrides(ルートのプロジェクトでのみ有効)で版を指定します";
+            }
+            return UPDATE_HINTS.npm;
+        case "Go": {
+            if (pkg.replaced_in_go_mod) {
+                return `go.modのreplaceで置き換えているため、requireではなくreplaceの版を更新します。${GO_MAJOR_NOTE}`;
+            }
+            if (relation === "direct")
+                return `直接依存です。go get <module>@<version>で更新します。${GO_MAJOR_NOTE}`;
+            if (relation === "transitive") {
+                return "間接依存(go.modの// indirect)です。go get <module>@<version>でgo.modの版を引き上げられます" +
+                    `(依存元のモジュールの更新で解消できる場合もあります)。${GO_MAJOR_NOTE}`;
+            }
+            return UPDATE_HINTS.Go;
+        }
+        case "PyPI":
+            if (relation === "direct") {
+                return "直接依存です。requirements.txtの版の指定、またはpyproject.toml・Pipfileの指定を更新し、lockfileを再生成します";
+            }
+            if (relation === "transitive") {
+                return "推移的依存です。それを要求している直接依存の更新か、pipの制約ファイル(-c)、uv・Poetry等の上書き設定で版を指定します";
+            }
+            return UPDATE_HINTS.PyPI;
+        default:
+            return UPDATE_HINTS[pkg.ecosystem];
+    }
+}
+function hintFields(pkg) {
+    const hint = updateHint(pkg);
     return hint === undefined ? {} : { update_hint: hint };
 }
+/** スキャン結果に付いた直接/推移的依存の項目を提案にも写す(無ければ何も出さない) */
+function relationFields(pkg) {
+    return {
+        ...(pkg.dependency_relation !== undefined ? { dependency_relation: pkg.dependency_relation } : {}),
+        ...(pkg.introduced_by !== undefined ? { introduced_by: pkg.introduced_by } : {}),
+        ...(pkg.introduced_by_omitted !== undefined ? { introduced_by_omitted: pkg.introduced_by_omitted } : {}),
+        ...(pkg.declared_in !== undefined ? { declared_in: pkg.declared_in } : {}),
+        ...(pkg.replaced_in_go_mod ? { replaced_in_go_mod: true } : {}),
+    };
+}
 /**
  * 未対応エコシステム・解釈できない現在の版は推奨を出さず、CVEをunfixedにも数えない。
  * 修正版の抽出がMaven専用だった頃、そのまま処理すると修正版のある脆弱性を
@@ -43,6 +95,7 @@ function notEvaluatedSuggestion(pkg, verification) {
         package: pkg.name,
         current_version: pkg.version,
         ecosystem: pkg.ecosystem,
+        ...relationFields(pkg),
         recommended_upgrade: null,
         upgrade_tier: null,
         upgrade_note: (verification === "unsupported_ecosystem"
@@ -117,7 +170,7 @@ export function suggestUpgradeForPackage(pkg) {
     if (scheme === null)
         return notEvaluatedSuggestion(pkg, "unsupported_ecosystem");
     if (!scheme.isValid(pkg.version))
-        return { ...notEvaluatedSuggestion(pkg, "unparseable_version"), ...hintFields(pkg.ecosystem) };
+        return { ...notEvaluatedSuggestion(pkg, "unparseable_version"), ...hintFields(pkg) };
     const details = pkg.vulnerabilities.map((vuln) => {
         const fix = rankCandidates(scheme, pkg.version, vuln.fixed_versions)[0];
         return {
@@ -145,6 +198,7 @@ export function suggestUpgradeForPackage(pkg) {
         package: pkg.name,
         current_version: pkg.version,
         ecosystem: pkg.ecosystem,
+        ...relationFields(pkg),
         recommended_upgrade: recommended,
         upgrade_tier: upgradeTier,
         ...(recommended !== null && scheme.isPrerelease(recommended) ? { recommended_is_prerelease: true } : {}),
@@ -152,7 +206,7 @@ export function suggestUpgradeForPackage(pkg) {
             ? "既知の修正版候補から、全修正対象CVEの影響範囲外と確認できる版が見つかりません。情報不足・未対応の範囲形式を含む場合も推奨を保留します。" +
                 (unparseableCount > 0 ? `${unparseableCount}件のCVEは修正版の記載をバージョンとして解釈できないため(tier: unparseable_fix)、推奨を保留しています。` : "")
             : buildNote(scheme, pkg, recommended, upgradeTier, fixableCount, unfixedCount),
-        ...hintFields(pkg.ecosystem),
+        ...hintFields(pkg),
         ...(pkg.version_is_lower_bound ? { version_is_lower_bound: true } : {}),
         per_cve_detail: details,
         verification: recommended === null ? "no_verified_candidate" : "verified",

package/dist/tools/scanProject.js

@@ -7,8 +7,10 @@
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
 import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
-import { parseOsvScanOutput } from "../osv/scanReport.js";
+import { packageSources, parseOsvScanOutput } from "../osv/scanReport.js";
+import { combineRelations, goModRelations, npmLockRelations, requirementsRelations, } from "../utils/dependencyRelations.js";
 import { sanitizeExternalText } from "../utils/externalText.js";
+import { readRegularFile } from "../utils/safeRead.js";
 import { detectProject } from "../utils/manifestDetector.js";
 import { normalizePypiName } from "../utils/requirementsFile.js";
 import { ScanSnapshot, snapshotManifests } from "../utils/scanSnapshot.js";
@@ -90,6 +92,65 @@ export function markLowerBounds(project, packages) {
  * 検証済みの正規化行だけを書いたコピー。コピーできず外したファイルはskippedFilesに記録する。
  * スナップショットは成功・失敗とも削除する。suggest_fixも同じスキャンを使う。
  */
+/** 直接/推移的依存の判定で読むpackage-lock.json・go.modの合計サイズの上限(LockfileKeyCacheと同じ) */
+const MAX_RELATION_LOCKFILE_BYTES = 256 * 1024 * 1024;
+const MAX_INTRODUCED_BY = 10;
+/**
+ * スキャンしたファイル(スナップショットのコピー)ごとに、直接/推移的依存の判定を用意する。
+ * 解析するのは検証済みのコピーだけで、元のファイルは読まない。判定できない形式・上限超過はnull(unknown)。
+ */
+export async function buildRelationLookups(copies, maxTotalBytes = MAX_RELATION_LOCKFILE_BYTES) {
+    const lookups = new Map();
+    let remaining = maxTotalBytes;
+    for (const { copy, format, originalRelative, entries } of copies) {
+        const lockDir = originalRelative === null ? "" : path.dirname(originalRelative);
+        let lookup = null;
+        try {
+            if (format === "package-lock.json" || format === "go.mod") {
+                // 残りの予算を上限に、読み込みの途中で打ち切る(予算を超えるファイルは全体を読まずにunknownにする)
+                const read = await readRegularFile(copy, { maxBytes: remaining });
+                if (read.ok) {
+                    remaining -= read.bytes.length;
+                    const text = read.bytes.toString("utf8");
+                    lookup = format === "go.mod" ? goModRelations(text) : npmLockRelations(JSON.parse(text));
+                }
+            }
+            else if (format === "requirements.txt" && entries !== undefined) {
+                lookup = requirementsRelations(entries);
+            }
+        }
+        catch {
+            lookup = null; // 解析できないファイルはunknown(スキャン自体は続ける)
+        }
+        lookups.set(copy, { lookup, lockDir });
+    }
+    return lookups;
+}
+/** パッケージに直接/推移的依存の別を付ける。項目は脆弱性の一覧より前に置く */
+function annotateRelations(packages, lookups) {
+    return packages.map((pkg) => {
+        const infos = [];
+        const declaredIn = new Set();
+        for (const source of packageSources(pkg)) {
+            const entry = lookups.get(source);
+            const info = entry?.lookup ? entry.lookup(pkg.name, pkg.version) : { relation: "unknown" };
+            infos.push(info);
+            for (const manifest of info.declaredIn ?? [])
+                declaredIn.add(path.join(entry.lockDir, manifest));
+        }
+        const { relation, introducedBy, replaced } = combineRelations(infos);
+        const { vulnerabilities, ...rest } = pkg;
+        return {
+            ...rest,
+            dependency_relation: relation,
+            ...(introducedBy.length > 0 ? { introduced_by: introducedBy.slice(0, MAX_INTRODUCED_BY).map(sanitizeExternalText) } : {}),
+            ...(introducedBy.length > MAX_INTRODUCED_BY ? { introduced_by_omitted: introducedBy.length - MAX_INTRODUCED_BY } : {}),
+            ...(declaredIn.size > 0 ? { declared_in: [...declaredIn].sort().map(sanitizeExternalText) } : {}),
+            ...(replaced ? { replaced_in_go_mod: true } : {}),
+            vulnerabilities,
+        };
+    });
+}
 export async function scanFromSnapshot(project, options) {
     const snapshot = await ScanSnapshot.create();
     try {
@@ -97,6 +158,10 @@ export async function scanFromSnapshot(project, options) {
             projectDir: project.projectDir,
             allowedRootReal: project.allowedRootReal,
         });
+        // コピーと元のファイルの対応(snapshotManifestsは外したもの以外を入力の順に返す)
+        const skippedOriginals = new Set(skipped.map((s) => s.path));
+        const scannedOriginals = project.targets.filter((t) => !skippedOriginals.has(t.path));
+        const relationSources = targets.map((copy, i) => ({ copy: copy.path, format: copy.format, originalRelative: path.relative(project.projectDir, scannedOriginals[i].path) }));
         // 親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) {
@@ -110,11 +175,15 @@ export async function scanFromSnapshot(project, options) {
         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" });
+            const generated = await snapshot.writeGenerated(`${copy.entries.join("\n")}\n`);
+            targets.push({ path: generated, format: "requirements.txt" });
+            relationSources.push({ copy: generated, format: "requirements.txt", originalRelative: copy.path, entries: copy.entries });
         }
         if (targets.length === 0)
             return parseOsvScanOutput({ results: [] });
-        return await withScopeNotes(project.skippedFiles, () => snapshot.guard(() => runOsvScan(targets, options)));
+        const report = await withScopeNotes(project.skippedFiles, () => snapshot.guard(() => runOsvScan(targets, options)));
+        // 判定はコピーを読むため、スナップショットを消す前に行う
+        return { ...report, packages: annotateRelations(report.packages, await buildRelationLookups(relationSources)) };
     }
     finally {
         await snapshot.cleanup();

package/dist/tools/scanSbom.js

@@ -3,12 +3,15 @@ import os from "node:os";
 import path from "node:path";
 import { runOsvSbomScan } from "../osv/runner.js";
 import { buildSbomReport } from "../osv/sbomReport.js";
+import { SBOM_DIR_PREFIX, trackTempDir } from "../utils/processCleanup.js";
 import { loadSbom } from "../utils/sbomInput.js";
 import { errorResult, jsonResult } from "./toolResult.js";
 export async function handleScanSbom(args, options = {}) {
     try {
         const input = await loadSbom(args.sbom_path, options);
-        const dir = await mkdtemp(path.join(await realpath(os.tmpdir()), "osv-mcp-sbom-"));
+        const dir = await mkdtemp(path.join(await realpath(os.tmpdir()), SBOM_DIR_PREFIX));
+        // シグナル等で終了しても残さない(processCleanup.ts)
+        const untrack = trackTempDir(dir);
         try {
             // A fixed filename selects the native parser, irrespective of the user's filename.
             const snapshotPath = path.join(dir, input.format === "CycloneDX" ? "input.cdx.json" : "input.spdx.json");
@@ -18,6 +21,7 @@ export async function handleScanSbom(args, options = {}) {
         }
         finally {
             await rm(dir, { recursive: true, force: true });
+            untrack();
         }
     }
     catch (error) {

package/dist/utils/dependencyRelations.js

@@ -0,0 +1,269 @@
+/**
+ * 直接/推移的依存の判定(docs/DESIGN_TODO.md「直接/推移的依存の区別(v0.7.0)詳細設計メモ」)。
+ *
+ * osv-scannerの出力には直接/推移的の区別がないため、スキャンしたファイル(スナップショットのコピー)を解析する。
+ * 新しい外部依存は追加せず、JSON(package-lock.json)と行形式(go.mod、requirements.txt)だけを扱う。
+ * - package-lock.json(v2以降): ルートとworkspaceの依存をNodeの解決規則で解決したものが直接依存、
+ *   そこからたどれるものが推移的依存。経由した直接依存の名前(introduced_by)と、宣言したpackage.json(declared_in)を返す
+ * - go.mod: `// indirect`のないrequireが直接依存。replaceの置換先にも同じ関係を当てる(osv-scannerは置換先で報告する)
+ * - requirements.txt: 本サーバーが書いたコピーの行が直接依存、それ以外(deps.devで解決された依存)が推移的依存
+ */
+/** たどる依存の辺の上限(巨大・悪意あるlockfileで処理が膨らまないように) */
+export const MAX_DEPENDENCY_EDGES = 2_000_000;
+const UNKNOWN = { relation: "unknown" };
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function depNames(entry, fields) {
+    const names = [];
+    for (const field of fields) {
+        const deps = entry[field];
+        if (isRecord(deps))
+            names.push(...Object.keys(deps));
+    }
+    return names;
+}
+const NODE_MODULES = "node_modules/";
+const INSTALLED_DEP_FIELDS = ["dependencies", "optionalDependencies", "peerDependencies"];
+const ROOT_DEP_FIELDS = [...INSTALLED_DEP_FIELDS, "devDependencies"];
+/** エントリの本来の名前: `name`があればそれ(別名のインストール)、なければキーの最後のnode_modules/以降 */
+function entryName(key, entry) {
+    if (typeof entry.name === "string" && entry.name !== "")
+        return entry.name;
+    const index = key.lastIndexOf(NODE_MODULES);
+    return index === -1 ? key : key.slice(index + NODE_MODULES.length);
+}
+/** ルート("")とworkspace(node_modules/の外のディレクトリ)が起点 */
+function isRoot(key) {
+    return key === "" || (!key.startsWith(NODE_MODULES) && !key.includes(`/${NODE_MODULES}`));
+}
+/**
+ * package-lock.json(v2以降)の依存の関係を判定する。`packages`が無い(v1形式)・上限を超える場合はnull。
+ */
+export function npmLockRelations(lock, maxEdges = MAX_DEPENDENCY_EDGES) {
+    const packages = isRecord(lock) ? lock.packages : undefined;
+    if (!isRecord(packages))
+        return null;
+    const entries = new Map();
+    for (const [key, value] of Object.entries(packages))
+        if (isRecord(value))
+            entries.set(key, value);
+    /** link(workspaceへのシンボリックリンク)をたどった実体のキー */
+    const follow = (key) => {
+        const entry = entries.get(key);
+        if (entry === undefined)
+            return null;
+        if (entry.link === true)
+            return typeof entry.resolved === "string" && entries.has(entry.resolved) ? entry.resolved : null;
+        return key;
+    };
+    /** Nodeの解決規則: <from>/node_modules/<名前>から上位のnode_modulesへ順に探す */
+    const resolve = (from, dep) => {
+        let base = from;
+        for (;;) {
+            const candidate = `${base === "" ? "" : `${base}/`}${NODE_MODULES}${dep}`;
+            if (entries.has(candidate))
+                return follow(candidate);
+            if (base === "")
+                return null;
+            const parent = base.lastIndexOf(`/${NODE_MODULES}`);
+            base = parent === -1 ? "" : base.slice(0, parent);
+        }
+    };
+    let edges = 0;
+    const direct = new Map(); // エントリ → 宣言したpackage.json
+    const introducedBy = new Map(); // エントリ → 経由した直接依存の名前
+    for (const root of [...entries.keys()].filter(isRoot)) {
+        const manifest = root === "" ? "package.json" : `${root}/package.json`;
+        for (const dep of depNames(entries.get(root), ROOT_DEP_FIELDS)) {
+            if (++edges > maxEdges)
+                return null;
+            const target = resolve(root, dep);
+            if (target === null || isRoot(target))
+                continue; // 未インストール、またはworkspace自身
+            let declared = direct.get(target);
+            if (declared === undefined)
+                direct.set(target, (declared = new Set()));
+            declared.add(manifest);
+        }
+    }
+    // 直接依存ごとに、到達できるエントリへその名前を記録する(訪問済みを記録して循環で止める)
+    for (const origin of direct.keys()) {
+        const originName = entryName(origin, entries.get(origin));
+        const visited = new Set([origin]);
+        const queue = [origin];
+        while (queue.length > 0) {
+            const current = queue.pop();
+            for (const dep of depNames(entries.get(current), INSTALLED_DEP_FIELDS)) {
+                if (++edges > maxEdges)
+                    return null;
+                const target = resolve(current, dep);
+                if (target === null || isRoot(target) || visited.has(target))
+                    continue;
+                visited.add(target);
+                queue.push(target);
+                let names = introducedBy.get(target);
+                if (names === undefined)
+                    introducedBy.set(target, (names = new Set()));
+                names.add(originName);
+            }
+        }
+    }
+    // 名前と版ごとにまとめる(同じ名前と版が複数の位置にインストールされうる)
+    const byPackage = new Map();
+    for (const [key, entry] of entries) {
+        if (isRoot(key) || entry.link === true || typeof entry.version !== "string")
+            continue;
+        const id = `${entryName(key, entry)}@${entry.version}`;
+        let info = byPackage.get(id);
+        if (info === undefined)
+            byPackage.set(id, (info = { direct: false, transitive: false, introducedBy: new Set(), declaredIn: new Set() }));
+        const declared = direct.get(key);
+        if (declared !== undefined) {
+            info.direct = true;
+            for (const manifest of declared)
+                info.declaredIn.add(manifest);
+        }
+        const names = introducedBy.get(key);
+        if (names !== undefined) {
+            info.transitive = true;
+            for (const name of names)
+                info.introducedBy.add(name);
+        }
+    }
+    return (name, version) => {
+        const info = byPackage.get(`${name}@${version}`);
+        if (info === undefined || (!info.direct && !info.transitive))
+            return UNKNOWN; // 未収録、またはどこからも到達しない
+        return {
+            relation: info.direct ? "direct" : "transitive",
+            ...(info.introducedBy.size > 0 ? { introducedBy: info.introducedBy } : {}),
+            ...(info.declaredIn.size > 0 ? { declaredIn: info.declaredIn } : {}),
+        };
+    };
+}
+/** go.modの1行からコメントを除いた本体と、`// indirect`の有無 */
+function splitGoComment(line) {
+    const index = line.indexOf("//");
+    if (index === -1)
+        return { body: line.trim(), indirect: false };
+    // Goと同じく、コメントが`indirect`だけか`indirect;`で始まる場合に間接依存とみなす
+    return { body: line.slice(0, index).trim(), indirect: /^indirect(?:;|$)/.test(line.slice(index + 2).trim()) };
+}
+/** go.modの版(`v1.2.3`)を、osv-scannerの報告と同じ`v`なしの形にする */
+function stripV(version) {
+    return version.startsWith("v") ? version.slice(1) : version;
+}
+/**
+ * go.modの依存の関係を判定する(requireの`// indirect`で判定し、版には依らない)。
+ * requireの単一行・括弧のブロック、replaceの単一行・ブロックを扱う。
+ * replaceはGoと同じく、版を限定したもの(`replace a v1.0.0 => ...`)はrequireの版が一致する場合だけ、
+ * 版を限定しないものは全版に適用する(同じモジュールでは版を限定したものが優先)。osv-scanner 2.4.0で同じ挙動を確認。
+ * 適用されたreplaceの置換先(osv-scannerはこのパスと版で報告する)に、置換元と同じ関係とreplacedを付ける。
+ */
+export function goModRelations(text) {
+    const requires = new Map();
+    const replaces = [];
+    let block = null;
+    for (const raw of text.split(/\r?\n/)) {
+        const { body, indirect } = splitGoComment(raw);
+        if (body === "")
+            continue;
+        if (block !== null && body === ")") {
+            block = null;
+            continue;
+        }
+        let directive = block;
+        let rest = body;
+        if (block === null) {
+            const head = /^(require|replace)\b\s*(.*)$/.exec(body);
+            if (head === null)
+                continue;
+            directive = head[1];
+            rest = head[2].trim();
+            if (rest === "(") {
+                block = directive;
+                continue;
+            }
+        }
+        const fields = rest.split(/\s+/);
+        if (directive === "require" && fields.length >= 2) {
+            const existing = requires.get(fields[0]);
+            // 同じモジュールが複数回requireされた場合は、直接依存を優先する
+            if (existing?.relation !== "direct") {
+                requires.set(fields[0], { relation: indirect ? "transitive" : "direct", version: stripV(fields[1]) });
+            }
+        }
+        else if (directive === "replace") {
+            const arrow = fields.indexOf("=>");
+            if ((arrow === 1 || arrow === 2) && fields[arrow + 1] !== undefined) {
+                replaces.push({
+                    from: fields[0],
+                    fromVersion: arrow === 2 ? stripV(fields[1]) : null,
+                    to: fields[arrow + 1],
+                    toVersion: fields[arrow + 2] !== undefined ? stripV(fields[arrow + 2]) : null,
+                });
+            }
+        }
+    }
+    /** osv-scannerが報告する名前 → 関係(置換されたモジュールは置換先の名前) */
+    const relations = new Map();
+    /** 適用されたreplaceで報告される「名前@版」(ローカルへの置換は置換元の名前) */
+    const replaced = new Set();
+    const replacedLocal = new Set();
+    const setRelation = (name, relation) => {
+        if (relations.get(name) !== "direct")
+            relations.set(name, relation);
+    };
+    for (const [modulePath, { relation, version }] of requires) {
+        setRelation(modulePath, relation);
+        const replace = replaces.find((r) => r.from === modulePath && r.fromVersion === version) ??
+            replaces.find((r) => r.from === modulePath && r.fromVersion === null);
+        if (replace === undefined)
+            continue;
+        if (replace.toVersion === null) {
+            replacedLocal.add(modulePath);
+        }
+        else {
+            setRelation(replace.to, relation);
+            replaced.add(`${replace.to}@${replace.toVersion}`);
+        }
+    }
+    return (name, version) => {
+        const relation = relations.get(name);
+        if (relation === undefined)
+            return UNKNOWN;
+        return replaced.has(`${name}@${version}`) || replacedLocal.has(name) ? { relation, replaced: true } : { relation };
+    };
+}
+/** PEP 503の正規化 */
+function normalizePypi(name) {
+    return name.toLowerCase().replace(/[-_.]+/g, "-");
+}
+/**
+ * requirements.txtのコピーに書いた行(`名前==版`等)から関係を判定する。
+ * 書いた名前が直接依存、それ以外(deps.devで解決された依存)が推移的依存。
+ */
+export function requirementsRelations(entries) {
+    const direct = new Set();
+    for (const line of entries) {
+        const name = /^[A-Za-z0-9][A-Za-z0-9._-]*/.exec(line)?.[0];
+        if (name !== undefined)
+            direct.add(normalizePypi(name));
+    }
+    return (name) => ({ relation: direct.has(normalizePypi(name)) ? "direct" : "transitive" });
+}
+/** 複数のファイルでの判定をまとめる。ファイルごとの関係がすべて同じならその値、異なればmixed */
+export function combineRelations(infos) {
+    const relations = new Set(infos.map((info) => info.relation));
+    const relation = relations.size === 1 ? [...relations][0] : relations.size === 0 ? "unknown" : "mixed";
+    const introducedBy = new Set();
+    const declaredIn = new Set();
+    for (const info of infos) {
+        for (const name of info.introducedBy ?? [])
+            introducedBy.add(name);
+        for (const manifest of info.declaredIn ?? [])
+            declaredIn.add(manifest);
+    }
+    return { relation, introducedBy: [...introducedBy].sort(), declaredIn: [...declaredIn].sort(), replaced: infos.some((info) => info.replaced) };
+}

package/dist/utils/processCleanup.js

@@ -0,0 +1,127 @@
+/**
+ * サーバー終了時の後始末: スキャン用の一時ディレクトリ(元のファイルのコピーを含む)と
+ * 実行中のosv-scannerプロセスを、サーバーより長く残さない。
+ *
+ * - 通常はスキャンごとの`finally`で削除するが、SIGTERM等で強制終了されると`finally`は実行されない
+ *   (2026-10-07 実機確認: scan_project中にSIGTERMを送るとosv-mcp-snap-*が残った)
+ * - そのため作成中の一時ディレクトリと子プロセスをここに登録し、シグナル・stdinの終了・
+ *   process.exitの時点で同期的に(fs.rmSync・SIGKILL)片付ける
+ * - 前回の異常終了(SIGKILL・電源断等)で残ったものは、起動時に条件を絞って削除する(removeStaleTempDirs)
+ */
+import { rmSync } from "node:fs";
+import { lstat, readdir, realpath, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+/** 本サーバーが作る一時ディレクトリの接頭辞(起動時の掃除はこれに完全一致するものだけを対象にする) */
+export const SNAPSHOT_DIR_PREFIX = "osv-mcp-snap-";
+export const SBOM_DIR_PREFIX = "osv-mcp-sbom-";
+/** mkdtempは接頭辞の後ろに6文字の英数字を付ける */
+const TEMP_DIR_NAME = /^osv-mcp-(?:snap|sbom)-[A-Za-z0-9]{6}$/;
+/**
+ * 起動時に削除する残骸の最終更新からの経過時間。別のサーバープロセス(複数のMCPクライアント等)が
+ * 使用中のディレクトリを消さないよう、スキャンのタイムアウト(既定120秒)より十分長くとる
+ */
+export const STALE_TEMP_DIR_AGE_MS = 24 * 60 * 60 * 1000;
+const tempDirs = new Set();
+const children = new Set();
+/** 一時ディレクトリを登録する。戻り値の関数で登録を外す(通常の削除後に呼ぶ) */
+export function trackTempDir(dir) {
+    tempDirs.add(dir);
+    return () => { tempDirs.delete(dir); };
+}
+/** 子プロセスを登録する。終了(close/error)時に自動で登録を外す */
+export function trackChildProcess(child) {
+    children.add(child);
+    const untrack = () => { children.delete(child); };
+    child.once("close", untrack);
+    child.once("error", untrack);
+}
+/**
+ * 登録済みの子プロセスを強制終了し、一時ディレクトリを同期的に削除する。
+ * シグナルハンドラ・exitイベントから呼ぶため、非同期処理を使わず例外も外に出さない
+ */
+export function cleanupSync() {
+    for (const child of children) {
+        // 終了済みのプロセスにはNode側で送らない(PIDの再利用で別プロセスを止めることはない)
+        try {
+            child.kill("SIGKILL");
+        }
+        catch { /* 後始末は続ける */ }
+    }
+    children.clear();
+    for (const dir of tempDirs) {
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        catch { /* 他のディレクトリの削除は続ける */ }
+    }
+    tempDirs.clear();
+}
+/** テスト用: 登録状況 */
+export function trackedCounts() {
+    return { tempDirs: tempDirs.size, children: children.size };
+}
+const SHUTDOWN_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
+let installed = false;
+/**
+ * 終了時の後始末を登録する(サーバー起動時に1回だけ呼ぶ)。
+ * - SIGTERM/SIGINT/SIGHUP: 後始末して慣例の終了コード(128+シグナル番号)で終了
+ * - stdinの終了(MCPクライアントがトランスポートを閉じた): 後始末して終了コード0で終了。
+ *   応答の送り先が無いため、実行中のスキャンの完了は待たない
+ * - process.exit・未捕捉例外による終了: exitイベントで後始末する
+ */
+export function installShutdownHandlers(stdin = process.stdin) {
+    if (installed)
+        return;
+    installed = true;
+    let shuttingDown = false;
+    const shutdown = (code) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        cleanupSync();
+        process.exit(code);
+    };
+    for (const signal of SHUTDOWN_SIGNALS) {
+        process.on(signal, () => shutdown(128 + (os.constants.signals[signal] ?? 0)));
+    }
+    stdin.once("end", () => shutdown(0));
+    stdin.once("close", () => shutdown(0));
+    process.on("exit", cleanupSync);
+}
+/**
+ * 前回の異常終了で残った一時ディレクトリを削除し、削除した数を返す。次の条件をすべて満たすものだけが対象:
+ * - 名前が本サーバーの接頭辞+mkdtempの6文字に完全一致する
+ * - シンボリックリンクではなく実体のディレクトリ(lstatで判定し、リンクはたどらない)
+ * - 所有者が現在のユーザー
+ * - 最終更新からSTALE_TEMP_DIR_AGE_MS以上経過している
+ *
+ * 一時ディレクトリは通常スティッキービット付きのため、自分が所有するエントリを他のユーザーが
+ * 判定と削除の間に差し替えることはできない。中のシンボリックリンクはrmがリンク自体を消すだけでたどらない。
+ * getuidの無い環境(Windows)では所有者を確認できないため何もしない
+ */
+export async function removeStaleTempDirs(options = {}) {
+    if (typeof process.getuid !== "function")
+        return 0;
+    const uid = process.getuid();
+    const root = options.tmpRoot ?? (await realpath(os.tmpdir()));
+    const now = options.now ?? Date.now();
+    const maxAgeMs = options.maxAgeMs ?? STALE_TEMP_DIR_AGE_MS;
+    let removed = 0;
+    for (const name of await readdir(root)) {
+        if (!TEMP_DIR_NAME.test(name))
+            continue;
+        const dir = path.join(root, name);
+        try {
+            const stats = await lstat(dir);
+            if (!stats.isDirectory() || stats.uid !== uid || now - stats.mtimeMs < maxAgeMs)
+                continue;
+            await rm(dir, { recursive: true, force: true });
+            removed++;
+        }
+        catch {
+            // 消えた・読めないものは対象外(他のディレクトリの掃除は続ける)
+        }
+    }
+    return removed;
+}

package/dist/utils/scanSnapshot.js

@@ -9,12 +9,14 @@
  *   最悪でも親が見つからないだけ)
  * - `..`を重ねた参照でスナップショットの外(本物のファイルシステム)に出る親POMは除外する
  * - コピーの合計サイズに上限を設ける
+ * - サーバーがシグナル等で終了しても残さないよう、作成直後に後始末の対象へ登録する(processCleanup.ts)
  */
 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 { SNAPSHOT_DIR_PREFIX, trackTempDir } from "./processCleanup.js";
 import { isInsideDir } from "./projectWalk.js";
 import { copyRegularFile } from "./safeRead.js";
 const DEFAULT_MAX_TOTAL_BYTES = 2 * 1024 * 1024 * 1024;
@@ -23,19 +25,22 @@ const MAX_PARENT_DEPTH = 10;
 export class ScanSnapshot {
     dir;
     maxTotalBytes;
+    untrack;
     copied = new Map();
     parentCache = new Map();
     /** 再現した配置のルートごとのディレクトリ → 元のルート("/"等) */
     mirroredRoots = new Map();
     used = 0;
     generated = 0;
-    constructor(dir, maxTotalBytes) {
+    constructor(dir, maxTotalBytes, untrack) {
         this.dir = dir;
         this.maxTotalBytes = maxTotalBytes;
+        this.untrack = untrack;
     }
     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);
+        const dir = await mkdtemp(path.join(await realpath(os.tmpdir()), SNAPSHOT_DIR_PREFIX));
+        // mkdtempの完了から登録までの間にシグナルの処理は割り込まない(同じ同期処理内で登録する)
+        return new ScanSnapshot(dir, maxTotalBytes, trackTempDir(dir));
     }
     /** 再現した配置のルート(実際のファイルシステムの"/"に相当) */
     get treeRoot() {
@@ -107,6 +112,7 @@ export class ScanSnapshot {
     }
     async cleanup() {
         await rm(this.dir, { recursive: true, force: true });
+        this.untrack();
     }
 }
 const UNPARSEABLE = "親POMの指定を確実に解釈できないため(親要素の重複、CDATA・DOCTYPE、プロパティ参照、UTF-8以外の文字コード等)、" +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osv-scanner-mcp",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "MCP server that wraps Google's OSV-Scanner to scan Java projects for known vulnerabilities",
   "type": "module",
   "license": "Apache-2.0",