poker-mcp 1.9.8 → 1.10.0

package/README.md

@@ -4,14 +4,121 @@ YAML-based input file management tool for radiation-shielding calculation code P
 
 ## 📋 クイック情報
 
-- **バージョン**: 1.9.8
-- **ツール数**: 36メソッド
+- **バージョン**: 1.10.0
+- **ツール数**: 36メソッド（非同期ジョブを有効にすると 39、GUI を外すと 1 減る）
 - **プロトコル**: MCP (Model Context Protocol) 1.0.0 完全準拠
 - **メインサーバー**: `src/mcp_server_stdio_v4.js`
 - **データ保存**: `~/.poker-mcp/`（`POKER_MCP_HOME`環境変数で変更可）
 - **核種データ**: `${POKER_INSTALL_PATH}/LIB/ICRP-07.NDX` を直接参照
 - **実行方式**: STDIO通信（MCPプロトコル標準）
 
+## 🆕 バージョン1.10.0の新機能
+
+### ⏳ 計算の非同期実行（既定では無効）
+
+時間のかかる計算を「投入して、あとで結果を取りに行く」形で扱えるようにしました。
+1 回のツール呼び出しは数秒で終わるので、MCP クライアントの待ち時間の上限や、
+リモート公開時の中継（Cloudflare Tunnel の約 100 秒など）に切られずに、
+何時間かかる計算でも扱えます。
+
+```javascript
+poker_submitCalculation({ yaml_file: "poker.yaml" })   // → { job_id: "20261013-053012-a1b2c3", status: "queued" }
+poker_getJobStatus({ job_id: "20261013-053012-a1b2c3" }) // → queued / running / succeeded / failed
+poker_getJobResult({ job_id: "20261013-053012-a1b2c3" }) // → executeCalculation と同じ形式の結果
+poker_getDoseMap({ detector_name: "D_map", job_id: "20261013-053012-a1b2c3" })
+```
+
+**既定では無効です。** 環境変数 `POKER_MCP_ASYNC=1` を設定したときだけ、上の 3 ツールが
+現れ、`poker_getDoseMap` に `job_id` 引数が付きます。設定しなければ、ツール一覧も動作も
+v1.9.9 と同じです。主にリモート公開したサーバで使うことを想定しています。
+
+```json
+"env": {
+  "POKER_MCP_HOME": "C:\\Users\\<username>\\poker_mcp_workspace",
+  "POKER_INSTALL_PATH": "C:/Poker",
+  "POKER_MCP_ASYNC": "1"
+}
+```
+
+| 環境変数 | 既定 | 内容 |
+|---|---|---|
+| `POKER_MCP_ASYNC` | 無効 | `1` で非同期ジョブを有効にする |
+| `POKER_MCP_ASYNC_CONCURRENCY` | 1 | 同時に実行する計算の数 |
+| `POKER_MCP_JOB_RETENTION_DAYS` | 7 | 終わったジョブを残す日数 |
+| `POKER_MCP_JOB_TIMEOUT_MIN` | 1440 | 1 件の計算の打ち切り時間 [分] |
+
+**計算の中身は同期と同じです。** ジョブも `poker_executeCalculation` と同じ処理で POKER を
+呼びます。`npm run test:jobs` で、同期と非同期の `.summary`・`.dose`・線量マップが
+全行一致することを確認しています（生成日時・計算時間・入力ファイルのパスの行を除く）。
+
+**投入した時点の入力で計算します。** YAML（と `.paths`）を
+`POKER_MCP_HOME/jobs/<ジョブID>/` にコピーしてから計算し、出力もそこに書きます。
+投入後に作業中の YAML を編集しても、投入済みのジョブには混ざらず、
+作業フォルダの `poker.yaml.summary` なども上書きしません。保留中の変更は含まれないので、
+必要なら先に `poker_applyChanges` で確定してください。
+
+**サーバを再起動してもジョブは残ります。** 状態は `job.json` に保存しています。
+実行中に再起動した場合、その計算は失われているため `failed`（`INTERRUPTED_BY_RESTART`）
+になります。待機中だったジョブは再び並び、実行されます。
+
+### 🖥️ GUI（poker_openGui）を使える環境でだけ登録
+
+`poker_openGui` は、MCP サーバが動いている機械の画面に POKER.exe を開きます。次のどれかに
+当たるときは、ツール一覧から外し、処理も登録しません（名前で直接呼ばれても実行しません）。
+
+| 条件 | 想定する場面 |
+|---|---|
+| `POKER_MCP_GUI=0` | **リモート公開したサーバ。** サーバに POKER が入っていても、GUI は利用者の手元ではなくサーバの画面に開き、利用者からは見えないため |
+| Windows 以外 | POKER.exe は Windows 専用 |
+| `POKER_INSTALL_PATH` に POKER.exe が無い | POKER の GUI を入れていない環境 |
+
+手元の Windows に POKER を入れて Claude Desktop から使う普段の環境では、従来どおり
+36 ツールが登録されます。判定はサーバの起動時に 1 回だけ行い、結果は起動ログに
+`poker_openGui: 有効（…）` / `無効（…）` と理由付きで出ます。
+
+GUI を外しても、計算（POKER_CUI.exe）・検証・CAD 連携・非同期ジョブには影響しません。
+POKER.exe を使うのは `poker_openGui` だけです。
+
+リモート公開するサーバの設定例（非同期ジョブを有効にし、GUI を外す）:
+
+```json
+"env": {
+  "POKER_MCP_HOME": "C:\\poker_mcp_workspace",
+  "POKER_INSTALL_PATH": "C:/Poker",
+  "POKER_MCP_ASYNC": "1",
+  "POKER_MCP_GUI": "0"
+}
+```
+
+## 🐛 バージョン1.9.9の修正
+
+npm で入れた環境（`npx poker-mcp`）でだけ現れる不具合と、失敗の伝え方の不具合を
+直しました。まっさらな Windows に npm パッケージから入れた環境で、CAD 連携を含む
+計算結果がリポジトリ上の実行と全行一致することを確認しています。
+
+### `poker_generateInput` が npm 版で動かなかった
+
+`tools/gen_input.py` と、それが読み込む `tools/scatter.py` が `package.json` の
+`files` から漏れていました。リポジトリから動かすと問題なく、npm から入れた環境で
+だけ `No module named 'gen_input'` で失敗していました。
+
+### 失敗が成功として返っていた
+
+CAD 系などのハンドラが返す `{ content, isError }` を、共通の処理がもう一度包んで
+いたため、`isError: true` が本文の中に埋もれ、MCP の上では成功として伝わって
+いました。AI クライアントは失敗に気づかないまま次の手順へ進みます。
+
+すでに MCP の応答形式になっている戻り値はそのまま返し、`{ success: false, ... }`
+を返すハンドラには `isError: true` を付けるようにしました。立体・ゾーン・線源など
+の検証エラーも、MCP の上で失敗として伝わります。
+
+### 計算エラーの処理そのものが落ちていた
+
+`poker_executeCalculation` が計算エラーを返す途中で
+`Cannot read properties of undefined (reading '_isRecoverableError')` になり、
+本来のエラー内容が隠れていました。ハンドラがオブジェクトから切り離して呼ばれる
+ため `this` が未定義になっていたのが原因です。
+
 ## 🆕 バージョン1.9.8の新機能
 
 ### 📜 `poker_getSchema` — ファイル書式を JSON Schema で取得
@@ -377,10 +484,27 @@ npx poker-mcp
 POKERのインストールディレクトリを指定します。以下の2つの用途で参照されます。
 
 - **ICRP-07.NDX の参照先**: `{POKER_INSTALL_PATH}/LIB/ICRP-07.NDX` を直接参照（v1.4.0以降、コピーなし）
-- **POKER.exe の場所**: `{POKER_INSTALL_PATH}/POKER.exe`（`poker_openGui` 使用時）
+- **POKER.exe の場所**: `{POKER_INSTALL_PATH}/POKER.exe`（`poker_openGui` 使用時）。
+  POKER.exe が見つからなければ `poker_openGui` は登録されません（v1.10.0）
 
 **デフォルト値**: `C:/Poker`（未設定時は `C:/Poker` を使用）
 
+#### `POKER_MCP_ASYNC` ほか（オプション、v1.10.0）
+計算の非同期実行（`poker_submitCalculation` など）を有効にします。既定では無効で、設定しなければ
+ツール一覧も動作も変わりません。詳しくは「[バージョン1.10.0の新機能](#-バージョン1100の新機能)」。
+
+| 変数 | 既定 | 内容 |
+|---|---|---|
+| `POKER_MCP_ASYNC` | 無効 | `1` で非同期ジョブを有効にする |
+| `POKER_MCP_ASYNC_CONCURRENCY` | 1 | 同時に実行する計算の数 |
+| `POKER_MCP_JOB_RETENTION_DAYS` | 7 | 終わったジョブを残す日数 |
+| `POKER_MCP_JOB_TIMEOUT_MIN` | 1440 | 1 件の計算の打ち切り時間 [分] |
+
+#### `POKER_MCP_GUI`（オプション、v1.10.0）
+`0` を設定すると `poker_openGui` を登録しません。リモート公開するサーバで使います
+（GUI がサーバの画面に開き、利用者からは見えないため）。Windows 以外の環境や、
+POKER.exe が見つからない環境では、設定しなくても登録されません。計算には影響しません。
+
 ```bash
 # Windows（コマンドプロンプト）
 set POKER_MCP_HOME=C:\Users\yoshi\poker_mcp_workspace
@@ -402,6 +526,7 @@ POKER_MCP_HOME/          # デフォルト: ~/.poker-mcp/
   ├── backups/           # 自動バックアップ（最大10世代）
   ├── data/              # ICRP-07.NDX 核種データベース
   ├── logs/              # error.log, combined.log
+  ├── jobs/              # 非同期ジョブ（POKER_MCP_ASYNC=1 のときだけ。既定 7 日で自動削除）
   └── config.json        # ユーザー設定（任意）
 ```
 
@@ -437,6 +562,13 @@ POKER_MCP_HOME/          # デフォルト: ~/.poker-mcp/
    > **⚠️ 注意:** `cwd`（作業ディレクトリ）の指定は不要です。`POKER_MCP_HOME`
    > 環境変数で管理するため、`cwd` を設定すると v1.2.5 以前の問題が再発します。
 
+   > **版の固定:** `npx` は一度取得した版を使い続けることがあります。確実に特定の版を
+   > 使うには `"args": ["poker-mcp@1.9.9"]` のように版を書きます。v1.9.8 以前の npm 版では
+   > `poker_generateInput` が動きません（v1.9.9 で修正）。
+
+   リモート公開するサーバ向けの設定（非同期ジョブを有効にし、GUI を外す）は
+   「[バージョン1.10.0の新機能](#-バージョン1100の新機能)」を参照してください。
+
 3. **Claude Desktopを再起動** してMCPサーバーを有効化
 
 ### 4. 動作確認
@@ -456,7 +588,9 @@ Claude Desktopで以下のようにテストできます：
 ## 🏆 主要機能
 
 ### ✅ **MCP完全対応**
-- **36メソッド完全実装**: 全ての放射線遮蔽計算入力管理機能
+- **36メソッド完全実装**: 全ての放射線遮蔽計算入力管理機能（非同期ジョブ有効時は 39）
+- **失敗の通知**: ツールが処理の結果として失敗（`success: false`）を返すと、MCP の `isError: true` が付く（v1.9.9）
+- **計算の非同期実行**: 長い計算を投入して後から結果を取得（`POKER_MCP_ASYNC=1`、v1.10.0）
 - **JSON-RPC 2.0準拠**: 標準プロトコル完全対応
 - **STDIO通信**: MCPクライアントとの標準通信方式
 - **自動バックアップ・ロールバック**: 企業品質のデータ保護
@@ -490,6 +624,10 @@ Claude Desktopで以下のようにテストできます：
 | **📐 CAD** | 2個 | CAD から入力と経路を生成 | generateInput・generatePaths |
 | **⚙️ System** | 6個 | システム制御 | applyChanges・executeCalculation・resetYaml・confirmDaughterNuclides・openGui・getDoseMap |
 | **📜 Schema** | 1個 | ファイル書式の取得 | getSchema |
+| **⏳ Job**（`POKER_MCP_ASYNC=1` のときだけ） | 3個 | 計算の非同期実行 | submitCalculation・getJobStatus・getJobResult |
+
+- `poker_openGui` は、Windows で POKER.exe が見つかり、`POKER_MCP_GUI=0` でないときだけ登録されます。
+- 非同期ジョブを有効にすると、`poker_getDoseMap` にジョブを指定する `job_id` 引数が付きます。
 
 ### 📋 **全36メソッド一覧**
 ```
@@ -508,6 +646,9 @@ CAD系 (2):           poker_generateInput, poker_generatePaths
 System系 (6):        poker_applyChanges, poker_executeCalculation, poker_resetYaml,
                      poker_confirmDaughterNuclides, poker_openGui, poker_getDoseMap
 Schema系 (1):        poker_getSchema
+
+（POKER_MCP_ASYNC=1 のとき追加）
+Job系 (3):           poker_submitCalculation, poker_getJobStatus, poker_getJobResult
 ```
 
 ## 📁 プロジェクト構造
@@ -542,6 +683,8 @@ POKER_MCP_HOME/
 ├── 📁 logs/                         # 📝 ログファイル
 │   ├── error.log
 │   └── combined.log
+├── 📁 jobs/                         # ⏳ 非同期ジョブ（POKER_MCP_ASYNC=1 のときだけ）
+│   └── <ジョブID>/                  # job.json・入力のコピー・.summary・.dose・stdout/stderr
 └── config.json                      # ユーザー設定（任意）
 ```
 
@@ -635,6 +778,22 @@ POKER_MCP_HOME/
 - **メモリ**: 512MB以上推奨（大規模検出器使用時は1GB以上）
 - **POKER 本体**: v2.1.5 以降（`POKER_INSTALL_PATH` で場所を指定）
 - **FreeCAD**: 1.0 以降（CAD連携を使う場合。`FREECAD_PATH`、未設定なら自動探索）
+- **POKER の GUI（POKER.exe）**: `poker_openGui` を使う場合のみ。Windows 専用
+
+## 🧪 開発者向けの確認
+
+リポジトリで次を実行します。`check:manifest` 以外は POKER 本体が必要です（`POKER_INSTALL_PATH` 既定 `C:/Poker`）。
+
+| コマンド | 内容 |
+|---|---|
+| `npm run check:manifest` | ツール定義とマニフェストの整合。既定・非同期有効・非同期有効かつ GUI 無効の 3 通り |
+| `npm run test:jobs` | 非同期ジョブ。同期との全行一致、投入後の編集が混ざらないこと、待ち行列、再起動後の復元 |
+| `npm run test:gui` | `poker_openGui` の登録条件（`POKER_MCP_GUI=0` で外れ、計算は従来どおり動く） |
+| `npm run test:schema` | `poker_getSchema` と `.dose` の読み取り |
+| `npm run test:pending` | 保留中の変更の表示 |
+| `npm run test:cad-validate` など | CAD 連携（FreeCAD が必要） |
+
+`test:jobs` と `test:gui` は、失敗があれば終了コード 1 で終わります。
 
 ## 🎯 実際の使用ワークフロー
 
@@ -659,6 +818,17 @@ POKER_MCP_HOME/
 
 ## 📝 更新履歴
 
+### v1.10.0 (2026-10)
+- ✨ 計算の非同期実行（`poker_submitCalculation` / `poker_getJobStatus` / `poker_getJobResult`、`poker_getDoseMap` の `job_id`）。`POKER_MCP_ASYNC=1` のときだけ有効
+- ✨ `poker_openGui` を GUI が使える環境でだけ登録（`POKER_MCP_GUI=0`、Windows 以外、POKER.exe なしで外す）
+- ✅ `npm run test:jobs`（同期との全行一致、入力のスナップショット、再起動後の復元）と `npm run test:gui` を追加
+- 🔧 `npm run check:manifest` が非同期ジョブ有効時・GUI 無効時のツール定義も照合
+
+### v1.9.9 (2026-10)
+- 🐛 `tools/gen_input.py` と `tools/scatter.py` を npm パッケージに同梱（`poker_generateInput` が npm 版で動かなかった）
+- 🐛 ツールの失敗が `isError: true` として伝わるよう修正（応答の二重包みを解消、`success: false` に `isError` を付与）
+- 🐛 `poker_executeCalculation` の計算エラー処理が `this` 未定義で落ちていた問題を修正
+
 ### v1.9.8 (2026-10)
 - ✨ `poker_getSchema`（入力YAML・`.paths`・`.summary`・`.dose` の書式を JSON Schema で取得）
 - 🐛 `poker_getDoseMap` が `.dose` の列構成を `information` から読むようになり、線量種別の増加に追随
@@ -749,6 +919,6 @@ obtained separately and licensed separately. poker-mcp は `poker_cui` を外部
 
 ---
 
-**🎯 Poker MCP Server v1.9.8**  
+**🎯 Poker MCP Server v1.10.0**  
 **プロトコル**: MCP 1.0.0 完全準拠  
 **作者**: Yoshihiro Hirao | **ライセンス**: MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poker-mcp",
-  "version": "1.9.8",
+  "version": "1.10.0",
   "description": "YAML-based input file management tool for radiation shielding calculation code POKER with MCP support - Enhanced with collision detection, daughter nuclide auto-completion, and environment variable support",
   "main": "src/mcp_server_stdio_v4.js",
   "type": "module",
@@ -11,7 +11,9 @@
     "start": "node src/mcp_server_stdio_v4.js",
     "dev": "nodemon src/mcp_server_stdio_v4.js",
     "prepare": "echo 'NPX ready: npx poker-mcp'",
-    "check:manifest": "node scripts/check-manifest-sync.mjs",
+    "check:manifest": "node scripts/check-manifest-sync.mjs && node scripts/check-manifest-sync.mjs --async && node scripts/check-manifest-sync.mjs --async --no-gui",
+    "test:jobs": "node tests/async-jobs.test.mjs",
+    "test:gui": "node tests/gui-switch.test.mjs",
     "test:pending": "node tests/pending-view.test.mjs",
     "test:cad": "node tests/cad-e2e.test.mjs",
     "test:cad-full": "node tests/cad-full.test.mjs",
@@ -56,7 +58,9 @@
   },
   "files": [
     "src/",
+    "tools/gen_input.py",
     "tools/gen_paths.py",
+    "tools/scatter.py",
     "tools/ray_trace_tri.py",
     "tools/poker_lib.py",
     "tools/audit_mfp.py",

package/src/mcp/handlers/calculationHandlers.js

@@ -7,19 +7,37 @@ import { TASKS_DIR } from '../../utils/paths.js';
 import { parseDoseSummary } from '../../utils/summaryParser.js';
 import { parseDoseMap } from '../../utils/doseMapParser.js';
 
-export function createCalculationHandlers(taskManager) {
+export function createCalculationHandlers(taskManager, { jobManager = null } = {}) {
   const calculationService = new CalculationService();
 
-  return {
+  // server.js はハンドラを handler(args) の形でオブジェクトから切り離して呼ぶため、
+  // 内部の補助関数は this ではなくこの変数経由で参照する。
+  const handlers = {
     async getDoseMap(args) {
       try {
         if (!args.detector_name) {
           throw new ValidationError('detector_name is required', 'detector_name', args.detector_name);
         }
-        const yamlFile = args.yaml_file || 'poker.yaml';
-        const absolutePathPattern = /^([a-zA-Z]:[\\\/]|\/)/;
-        const resolvedYamlFile = absolutePathPattern.test(yamlFile) ? yamlFile : path.join(TASKS_DIR, yamlFile);
-        const dosePath = resolvedYamlFile + '.dose';
+        let dosePath;
+        if (args.job_id) {
+          // 非同期ジョブの結果を読む（ジョブ専用フォルダの .dose）
+          if (!jobManager) {
+            return { success: false, error: 'job_id は非同期ジョブが有効なとき（POKER_MCP_ASYNC=1）だけ使えます' };
+          }
+          const job = jobManager.get(args.job_id);
+          if (!job) {
+            return { success: false, error: `ジョブが見つかりません: ${args.job_id}`, error_type: 'JOB_NOT_FOUND' };
+          }
+          if (job.status !== 'succeeded') {
+            return { success: false, error: `ジョブ ${args.job_id} は完了していません（status: ${job.status}）`, status: job.status };
+          }
+          dosePath = job.outputs.dose_file;
+        } else {
+          const yamlFile = args.yaml_file || 'poker.yaml';
+          const absolutePathPattern = /^([a-zA-Z]:[\\\/]|\/)/;
+          const resolvedYamlFile = absolutePathPattern.test(yamlFile) ? yamlFile : path.join(TASKS_DIR, yamlFile);
+          dosePath = resolvedYamlFile + '.dose';
+        }
         // .dose は poker_cui 完了直後に書き込まれるが、完了検知からディスク反映までに数秒の
         // ばらつきがある。実運用（executeCalculation とは別コール）では準備済みだが、直後呼び出しに
         // 備え、準備できるまで最大約10秒リトライする（未準備時のみ待機）。
@@ -231,8 +249,8 @@ export function createCalculationHandlers(taskManager) {
             mcp_error_code: error.mcpErrorCode,
             details: {
               category: 'calculation_error',
-              recoverable: this._isRecoverableError(error.code),
-              suggestions: this._getErrorSuggestions(error.code, error.context)
+              recoverable: handlers._isRecoverableError(error.code),
+              suggestions: handlers._getErrorSuggestions(error.code, error.context)
             }
           };
         }
@@ -343,4 +361,6 @@ export function createCalculationHandlers(taskManager) {
       }
     }
   };
+
+  return handlers;
 }

package/src/mcp/handlers/index.js

@@ -5,16 +5,25 @@ import { createTransformHandlers } from './transformHandlers.js';
 import { createBuildupFactorHandlers } from './buildupFactorHandlers.js';
 import { createSourceHandlers } from './sourceHandlers.js';
 import { createDetectorHandlers } from './detectorHandlers.js';
-import { createUnitHandlers } from './unitHandlers.js';
-import { createThinnedIndicesHandlers } from './thinnedIndicesHandlers.js';
+import { createUnitHandlers } from './unitHandlers.js';
+import { createThinnedIndicesHandlers } from './thinnedIndicesHandlers.js';
 import { createCadHandlers } from './cadHandlers.js';
 import { createCalculationHandlers } from './calculationHandlers.js';
 import { resetHandlers } from './resetHandlers.js';
 import { createDaughterNuclideHandler } from './daughterNuclideHandler.js';
-import { createGuiHandlers } from './guiHandlers.js';
+import { createGuiHandlers } from './guiHandlers.js';
 import { createSchemaHandlers } from './schemaHandlers.js';
+import { createJobHandlers } from './jobHandlers.js';
 
-export function createAllHandlers(taskManager) {
+/**
+ * @param {Object} taskManager
+ * @param {Object} [opts]
+ * @param {import('../../services/JobManager.js').JobManager|null} [opts.jobManager]
+ *   非同期ジョブが有効なときだけ渡される。null ならジョブ系のハンドラは登録しない。
+ * @param {boolean} [opts.guiEnabled=true]
+ *   false なら poker_openGui のハンドラを登録しない（ツール名で直接呼ばれても実行しない）。
+ */
+export function createAllHandlers(taskManager, { jobManager = null, guiEnabled = true } = {}) {
   return {
     // 立体操作
     ...createBodyHandlers(taskManager),
@@ -35,12 +44,15 @@ export function createAllHandlers(taskManager) {
     ...createDetectorHandlers(taskManager),
     
     // 単位操作
-    ...createUnitHandlers(taskManager),
-    ...createThinnedIndicesHandlers(taskManager),
+    ...createUnitHandlers(taskManager),
+    ...createThinnedIndicesHandlers(taskManager),
     ...createCadHandlers(taskManager),
     
     // 計算操作
-    ...createCalculationHandlers(taskManager),
+    ...createCalculationHandlers(taskManager, { jobManager }),
+
+    // 非同期ジョブ（POKER_MCP_ASYNC=1 のときだけ）
+    ...(jobManager ? createJobHandlers(taskManager, jobManager) : {}),
 
     // 子孫核種確認操作
     confirmDaughterNuclides: createDaughterNuclideHandler(taskManager),
@@ -48,10 +60,10 @@ export function createAllHandlers(taskManager) {
     // リセット操作
     resetYaml: resetHandlers.resetYaml(taskManager),
 
-    // GUI表示操作
-    ...createGuiHandlers(taskManager),
-
-    // スキーマ取得（poker_cui --schema）
+    // GUI表示操作（Windows で POKER.exe があり、POKER_MCP_GUI=0 でないときだけ）
+    ...(guiEnabled ? createGuiHandlers(taskManager) : {}),
+
+    // スキーマ取得（poker_cui --schema）
     ...createSchemaHandlers(),
     
     // 共通操作

package/src/mcp/handlers/jobHandlers.js

@@ -0,0 +1,183 @@
+// mcp/handlers/jobHandlers.js - 計算の非同期実行のハンドラ
+import fs from 'fs';
+import path from 'path';
+import { ValidationError } from '../../utils/errors.js';
+import { logger } from '../../utils/logger.js';
+import { TASKS_DIR } from '../../utils/paths.js';
+import { parseDoseSummary } from '../../utils/summaryParser.js';
+import { TERMINAL_STATUSES } from '../../services/JobManager.js';
+
+const ABSOLUTE = /^([a-zA-Z]:[\\\/]|\/)/;
+const resolveTaskPath = (p) => (ABSOLUTE.test(p) ? p : path.join(TASKS_DIR, p));
+
+export function createJobHandlers(taskManager, jobManager) {
+  const statusView = (job) => {
+    const now = Date.now();
+    const start = job.started_at ? Date.parse(job.started_at) : null;
+    const end = job.finished_at ? Date.parse(job.finished_at) : null;
+    return {
+      job_id: job.id,
+      status: job.status,
+      submitted_at: job.submitted_at,
+      started_at: job.started_at,
+      finished_at: job.finished_at,
+      queue_position: jobManager.queuePosition(job.id),
+      running_seconds: start ? Math.round(((end || now) - start) / 1000) : null,
+      input_file: job.input.yaml_source,
+      path_input: job.input.path_input_source,
+      ...(job.status === 'failed' ? { error: job.error } : {})
+    };
+  };
+
+  return {
+    async submitCalculation(args) {
+      if (!args.yaml_file) {
+        throw new ValidationError('YAML file is required', 'yaml_file', args.yaml_file);
+      }
+      const yamlFile = resolveTaskPath(args.yaml_file);
+      if (!/\.(yaml|yml)$/i.test(yamlFile)) {
+        throw new ValidationError('YAML file must have .yaml or .yml extension', 'yaml_file', args.yaml_file);
+      }
+      if (!fs.existsSync(yamlFile)) {
+        throw new ValidationError(`YAML file not found: ${yamlFile}`, 'yaml_file', args.yaml_file);
+      }
+      let pathInput = null;
+      if (args.path_input) {
+        pathInput = resolveTaskPath(args.path_input);
+        if (!fs.existsSync(pathInput)) {
+          throw new ValidationError(`path_input not found: ${pathInput}`, 'path_input', args.path_input);
+        }
+      }
+      const outputFiles = args.output_files || {};
+      for (const [key, name] of Object.entries(outputFiles)) {
+        if (name && !/^[a-zA-Z0-9_\-\.]+\.(yaml|yml)$/.test(name)) {
+          throw new ValidationError(`Output file ${key} must be a file name ending with .yaml or .yml`, `output_files.${key}`, name);
+        }
+      }
+
+      // 同期の executeCalculation と同じ事前検証を、投入の時点で行う。
+      // 重大エラー（立体干渉を除く）があれば受け付けない。
+      if (taskManager?.dataManager) {
+        const v = await taskManager.dataManager.performPreCalculationValidation();
+        const critical = (v.criticalErrors || []).filter((e) => e.type !== 'collision_detected');
+        if (critical.length > 0) {
+          return {
+            success: false,
+            error: 'CRITICAL_VALIDATION_ERRORS',
+            error_type: 'PRE_VALIDATION_FAILED',
+            message: '計算実行前に解決が必要な重大エラーがあるため、ジョブを受け付けませんでした',
+            critical_errors: critical
+          };
+        }
+      }
+
+      const job = await jobManager.submit({
+        yamlFile,
+        pathInput,
+        summaryOptions: args.summary_options || {},
+        outputFiles
+      });
+
+      return {
+        success: true,
+        message: '計算を受け付けました。poker_getJobStatus で進み具合を確認し、終わったら poker_getJobResult で結果を取得してください。',
+        job_id: job.id,
+        status: job.status,
+        queue_position: jobManager.queuePosition(job.id),
+        input: {
+          yaml_file: yamlFile,
+          yaml_sha256: job.input.yaml_sha256,
+          path_input: pathInput
+        }
+      };
+    },
+
+    async getJobStatus(args = {}) {
+      if (!args.job_id) {
+        const jobs = jobManager.list(20).map(statusView);
+        return {
+          success: true,
+          running: jobManager.running.size,
+          queued: jobManager.queue.length,
+          concurrency: jobManager.concurrency,
+          jobs
+        };
+      }
+      const job = jobManager.get(args.job_id);
+      if (!job) {
+        return { success: false, error: `ジョブが見つかりません: ${args.job_id}`, error_type: 'JOB_NOT_FOUND' };
+      }
+      return { success: true, ...statusView(job) };
+    },
+
+    async getJobResult(args) {
+      const job = jobManager.get(args.job_id);
+      if (!job) {
+        return { success: false, error: `ジョブが見つかりません: ${args.job_id}`, error_type: 'JOB_NOT_FOUND' };
+      }
+      if (!TERMINAL_STATUSES.has(job.status)) {
+        return {
+          success: true,
+          ready: false,
+          ...statusView(job),
+          message: 'まだ終わっていません。しばらくおいて poker_getJobStatus で確認してください。'
+        };
+      }
+      if (job.status === 'failed') {
+        return {
+          success: false,
+          ready: true,
+          ...statusView(job),
+          error: job.error?.message,
+          error_type: job.error?.code || 'JOB_FAILED',
+          details: job.error
+        };
+      }
+
+      const files = {};
+      for (const [key, p] of Object.entries(job.outputs)) {
+        try {
+          const st = fs.statSync(p);
+          files[key] = { exists: true, size: st.size, path: p };
+        } catch (e) {
+          files[key] = { exists: false, path: p };
+        }
+      }
+      const stdout = jobManager.readOutput(job.id, 'stdout.txt');
+      const stderr = jobManager.readOutput(job.id, 'stderr.txt');
+
+      const response = {
+        success: true,
+        ready: true,
+        ...statusView(job),
+        message: 'Radiation shielding calculation completed successfully',
+        calculation: {
+          input_file: job.input.yaml_source,
+          snapshot_file: job.input.yaml_file,
+          yaml_sha256: job.input.yaml_sha256,
+          execution_time_ms: job.execution_time_ms,
+          options: job.summary_options
+        },
+        outputs: {
+          console: { stdout_length: stdout.length, stderr_length: stderr.length },
+          files
+        },
+        details: { stdout, stderr }
+      };
+
+      try {
+        const parsed = parseDoseSummary(job.outputs.summary_file);
+        if (parsed) {
+          response.result_total = parsed.result_total;
+          response.dose_columns = parsed.columns;
+          if (parsed.notes && parsed.notes.length) response.calculation_notes = parsed.notes;
+          if (parsed.elapsed_time) response.calculation.elapsed_time = parsed.elapsed_time;
+          if (parsed.warnings && parsed.warnings.length) response.calculation_warnings = parsed.warnings;
+        }
+      } catch (e) {
+        logger.warn('summary 構造化パースをスキップ', { job: job.id, error: e.message });
+      }
+      return response;
+    }
+  };
+}

package/src/mcp/middleware/errorHandler.js

@@ -37,11 +37,29 @@ export function handleMcpError(error, context = {}) {
   return new McpError(ErrorCode.InternalError, `内部エラー: ${error.message}`);
 }
 
+/**
+ * ハンドラの戻り値を MCP の CallToolResult に整える。
+ *  - すでに CallToolResult の形（content 配列を持つ）ならそのまま返す。
+ *    包み直すと isError が text の中に埋もれ、失敗が成功として伝わってしまう。
+ *  - { success: false, ... } を返すハンドラは失敗として isError: true を付ける。
+ *    AI クライアントは本文を読まずに isError で成否を判断することがあるため。
+ */
+export function toCallToolResult(result) {
+  if (result && typeof result === 'object' && Array.isArray(result.content)) {
+    return result;
+  }
+  const wrapped = { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+  if (result && typeof result === 'object' && result.success === false) {
+    wrapped.isError = true;
+  }
+  return wrapped;
+}
+
 export function safeExecute(fn, context = {}) {
   return async (request) => {
     try {
       const result = await fn(request);
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+      return toCallToolResult(result);
     } catch (error) {
       throw handleMcpError(error, context);
     }