@minimalcorp/tsunagi 0.0.4 → 0.1.0

package/dist/server/routes/editor.js

@@ -1,36 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.editorRoutes = editorRoutes;
-const promises_1 = require("fs/promises");
-const crypto_1 = require("crypto");
-const editor_session_store_js_1 = require("../editor-session-store.js");
-const pty_manager_js_1 = require("../pty-manager.js");
-async function editorRoutes(fastify) {
+import { readFile, writeFile } from 'fs/promises';
+import { randomUUID } from 'crypto';
+import { editorSessionStore } from '../editor-session-store.js';
+import { ptyManager } from '../pty-manager.js';
+export async function editorRoutes(fastify) {
     const f = fastify;
     // セッション作成: CLIスクリプトが filePath を送信、サーバーがファイルを読む
-    f.post('/api/editor/session', async (request, reply) => {
+    f.post('/editor/session', async (request, reply) => {
         const { filePath, tabId } = request.body;
         if (!filePath) {
             return reply.status(400).send('filePath is required');
         }
         let content = '';
         try {
-            content = await (0, promises_1.readFile)(filePath, 'utf8');
+            content = await readFile(filePath, 'utf8');
         }
         catch {
             // ファイルが存在しない or 空の場合は空文字で続行
         }
-        const sessionId = (0, crypto_1.randomUUID)();
-        editor_session_store_js_1.editorSessionStore.set(sessionId, {
+        const sessionId = randomUUID();
+        editorSessionStore.set(sessionId, {
             filePath,
             content,
             status: 'pending',
             createdAt: Date.now(),
+            tabId: tabId ?? null,
         });
         // tabIdが指定されていれば、最後にinputを送信したソケットにのみ送信
         // （同じtabルームに複数ブラウザタブのソケットが参加している場合の隔離）
         if (tabId) {
-            const activeSocketId = pty_manager_js_1.ptyManager.getActiveSocket(tabId);
+            const activeSocketId = ptyManager.getActiveSocket(tabId);
             if (activeSocketId) {
                 f.io.to(activeSocketId).emit('editor:open', { sessionId, content });
             }
@@ -46,21 +44,39 @@ async function editorRoutes(fastify) {
     });
     // セッション状態取得: CLIスクリプトがポーリングで使用
     // "done" or "pending" をプレーンテキストで返す（Shell script が JSON パース不要）
-    f.get('/api/editor/session/:id', async (request, reply) => {
-        const session = editor_session_store_js_1.editorSessionStore.get(request.params.id);
+    f.get('/editor/session/:id', async (request, reply) => {
+        const session = editorSessionStore.get(request.params.id);
         if (!session) {
             return reply.status(404).send('not found');
         }
         return reply.type('text/plain').send(session.status);
     });
     // セッション完了: ブラウザが編集完了時に呼び出す。サーバーがファイルに書き戻す
-    f.post('/api/editor/session/:id/complete', async (request, reply) => {
-        const session = editor_session_store_js_1.editorSessionStore.get(request.params.id);
+    f.post('/editor/session/:id/complete', async (request, reply) => {
+        const session = editorSessionStore.get(request.params.id);
         if (!session) {
             return reply.status(404).send({ error: 'Session not found' });
         }
-        await (0, promises_1.writeFile)(session.filePath, request.body.content, 'utf8');
+        await writeFile(session.filePath, request.body.content, 'utf8');
         session.status = 'done';
+        // sh が polling で "done" を検知して exit し claude が foreground に戻った後、
+        // cols を一瞬変えることで SIGWINCH を発火させる。
+        // rows 変更と異なり cols 変更では Ink が全画面クリア + 全 UI 再描画を行うため、
+        // $EDITOR exit 後に blank になる余白が解消される。
+        // 300ms: server が /complete を受信した時点が T=0。sh の polling(最大100ms) +
+        //        exit + claude foreground 復帰 で ~150ms。余裕を持たせた値。
+        if (session.tabId) {
+            const ptySession = ptyManager.getSession(session.tabId);
+            if (ptySession) {
+                const { cols, rows } = ptySession.pty;
+                setTimeout(() => {
+                    ptySession.pty.resize(cols + 1, rows);
+                    setTimeout(() => {
+                        ptySession.pty.resize(cols, rows);
+                    }, 100);
+                }, 300);
+            }
+        }
         return reply.send({ ok: true });
     });
 }

package/dist/server/routes/env.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function envRoutes(fastify: FastifyInstance): Promise<void>;

package/dist/server/routes/env.js

@@ -0,0 +1,144 @@
+import * as envRepo from '../lib/repositories/environment.js';
+export async function envRoutes(fastify) {
+    // GET /env
+    fastify.get('/env', async (request, reply) => {
+        try {
+            const { owner, repo } = request.query;
+            const scope = request.query.scope || 'global';
+            if (scope === 'owner' && !owner) {
+                return reply.status(400).send({
+                    error: 'Missing required query parameter: owner for scope=owner',
+                });
+            }
+            if (scope === 'repo' && (!owner || !repo)) {
+                return reply.status(400).send({
+                    error: 'Missing required query parameters: owner, repo for scope=repo',
+                });
+            }
+            const env = await envRepo.getEnv(scope, owner || undefined, repo || undefined);
+            return reply.status(200).send({ data: { env } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'GET /env error');
+            return reply.status(500).send({ error: 'Failed to fetch environment variables' });
+        }
+    });
+    // POST /env
+    fastify.post('/env', async (request, reply) => {
+        try {
+            const { key, value, scope, owner, repo } = request.body;
+            if (!key || !value || !scope) {
+                return reply.status(400).send({ error: 'Missing required fields: key, value, scope' });
+            }
+            if (scope === 'owner' && !owner) {
+                return reply.status(400).send({ error: 'Missing required field: owner for scope=owner' });
+            }
+            if (scope === 'repo' && (!owner || !repo)) {
+                return reply.status(400).send({
+                    error: 'Missing required fields: owner, repo for scope=repo',
+                });
+            }
+            await envRepo.setEnv(key, value, scope, owner, repo);
+            return reply.status(201).send({ data: { success: true } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'POST /env error');
+            return reply.status(500).send({ error: 'Failed to set environment variable' });
+        }
+    });
+    // PUT /env
+    fastify.put('/env', async (request, reply) => {
+        try {
+            const { key, value, scope, owner, repo } = request.body;
+            if (!key || !value || !scope) {
+                return reply.status(400).send({ error: 'Missing required fields: key, value, scope' });
+            }
+            if (scope === 'owner' && !owner) {
+                return reply.status(400).send({ error: 'Missing required field: owner for scope=owner' });
+            }
+            if (scope === 'repo' && (!owner || !repo)) {
+                return reply.status(400).send({
+                    error: 'Missing required fields: owner, repo for scope=repo',
+                });
+            }
+            await envRepo.setEnv(key, value, scope, owner, repo);
+            return reply.status(200).send({ data: { success: true } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'PUT /env error');
+            return reply.status(500).send({ error: 'Failed to update environment variable' });
+        }
+    });
+    // DELETE /env
+    fastify.delete('/env', async (request, reply) => {
+        try {
+            const { owner, repo } = request.query;
+            const key = request.query.key;
+            const scope = request.query.scope;
+            if (!key || !scope) {
+                return reply.status(400).send({
+                    error: 'Missing required query parameters: key, scope',
+                });
+            }
+            if (scope === 'owner' && !owner) {
+                return reply.status(400).send({
+                    error: 'Missing required query parameter: owner for scope=owner',
+                });
+            }
+            if (scope === 'repo' && (!owner || !repo)) {
+                return reply.status(400).send({
+                    error: 'Missing required query parameters: owner, repo for scope=repo',
+                });
+            }
+            const success = await envRepo.deleteEnv(key, scope, owner || undefined, repo || undefined);
+            if (!success) {
+                return reply.status(404).send({ error: 'Environment variable not found' });
+            }
+            return reply.status(200).send({ data: { success: true } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'DELETE /env error');
+            return reply.status(500).send({ error: 'Failed to delete environment variable' });
+        }
+    });
+    // GET /env/list
+    fastify.get('/env/list', async (request, reply) => {
+        try {
+            const { owner, repo } = request.query;
+            const scope = request.query.scope || 'global';
+            if (scope === 'owner' && !owner) {
+                return reply.status(400).send({
+                    error: 'Missing required query parameter: owner for scope=owner',
+                });
+            }
+            if (scope === 'repo' && (!owner || !repo)) {
+                return reply.status(400).send({
+                    error: 'Missing required query parameters: owner, repo for scope=repo',
+                });
+            }
+            const envVars = await envRepo.getAllEnv(scope, owner || undefined, repo || undefined);
+            return reply.status(200).send({ data: { envVars } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'GET /env/list error');
+            return reply.status(500).send({ error: 'Failed to fetch environment variables' });
+        }
+    });
+    // PATCH /env/toggle
+    fastify.patch('/env/toggle', async (request, reply) => {
+        try {
+            const { key, scope, enabled, owner, repo } = request.body;
+            if (!key || !scope || typeof enabled !== 'boolean') {
+                return reply.status(400).send({ error: 'key, scope, and enabled are required' });
+            }
+            await envRepo.toggleEnv(key, scope, enabled, owner, repo);
+            return reply.status(200).send({ data: { success: true } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'Failed to toggle environment variable');
+            return reply.status(500).send({
+                error: error instanceof Error ? error.message : 'Failed to toggle environment variable',
+            });
+        }
+    });
+}

package/dist/server/routes/hooks.d.ts

@@ -0,0 +1,25 @@
+import type { FastifyInstance } from 'fastify';
+interface ClaudeHookBody {
+    hook_event_name: string;
+    session_id?: string;
+    transcript_path?: string;
+    cwd?: string;
+    permission_mode?: string;
+    prompt?: string;
+    tool_name?: string;
+    tool_use_id?: string;
+    tool_input?: Record<string, unknown>;
+    tool_response?: Record<string, unknown>;
+    error?: string;
+    error_details?: string;
+    reason?: string;
+}
+export interface HookEvent {
+    receivedAt: string;
+    event: string;
+    sessionId?: string;
+    raw: ClaudeHookBody;
+}
+export declare const hookEvents: HookEvent[];
+export declare function hooksRoutes(fastify: FastifyInstance): Promise<void>;
+export {};

package/dist/server/routes/hooks.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hookEvents = void 0;
-exports.hooksRoutes = hooksRoutes;
-exports.hookEvents = [];
+import { prisma } from '../lib/db.js';
+export const hookEvents = [];
 const sessionTasks = new Map();
 /** TaskEntryリストをTodo形式に変換 */
 function tasksToTodos(tasks) {
@@ -11,23 +8,22 @@ function tasksToTodos(tasks) {
         status: t.status === 'in_progress' ? 'in_progress' : t.status,
     }));
 }
-/** Next.js内部APIでタブのステータス（+ todos）をDB更新する */
+/** DBでタブのステータス（+ todos）を直接更新する */
 async function updateTabStatus(sessionId, status, todos) {
     try {
-        const response = await fetch(`http://localhost:2791/api/internal/tabs/${sessionId}/status`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ status, ...(todos !== undefined && { todos }) }),
+        await prisma.tab.updateMany({
+            where: { tabId: sessionId },
+            data: {
+                status,
+                ...(todos !== undefined && { todos: JSON.stringify(todos) }),
+            },
         });
-        if (!response.ok) {
-            console.warn(`[hooks] Failed to update tab status: ${response.status}`);
-        }
     }
     catch (err) {
-        console.warn(`[hooks] Failed to reach Next.js API for status update:`, err);
+        console.warn(`[hooks] Failed to update tab status in DB:`, err);
     }
 }
-async function hooksRoutes(fastify) {
+export async function hooksRoutes(fastify) {
     const io = fastify.io;
     // POST /hooks/claude - Claude CLIからのhook受信
     fastify.post('/hooks/claude', async (request, reply) => {
@@ -36,15 +32,15 @@ async function hooksRoutes(fastify) {
         const sessionId = body.session_id;
         fastify.log.info({ eventName, sessionId }, 'Claude hook received');
         // メモリに記録（確認用）
-        exports.hookEvents.push({
+        hookEvents.push({
             receivedAt: new Date().toISOString(),
             event: eventName,
             sessionId,
             raw: body,
         });
         // 最新100件のみ保持
-        if (exports.hookEvents.length > 100)
-            exports.hookEvents.splice(0, exports.hookEvents.length - 100);
+        if (hookEvents.length > 100)
+            hookEvents.splice(0, hookEvents.length - 100);
         if (sessionId) {
             const room = `tab:${sessionId}`;
             switch (eventName) {
@@ -141,16 +137,6 @@ async function hooksRoutes(fastify) {
     });
     // GET /hooks/events - 受信済みhookイベント一覧（確認用）
     fastify.get('/hooks/events', async () => {
-        return { events: exports.hookEvents };
-    });
-    // POST /internal/emit-status - Socket.IO status-changed を発火（Next.jsから呼び出し用）
-    fastify.post('/internal/emit-status', async (request, reply) => {
-        const { sessionId, status } = request.body;
-        if (!sessionId || !status) {
-            return reply.status(400).send({ error: 'sessionId and status are required' });
-        }
-        const room = `tab:${sessionId}`;
-        io.to(room).emit('status-changed', { sessionId, status });
-        return reply.status(200).send({ ok: true });
+        return { events: hookEvents };
     });
 }

package/dist/server/routes/internal.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function internalRoutes(fastify: FastifyInstance): Promise<void>;

package/dist/server/routes/internal.js

@@ -0,0 +1,52 @@
+import { prisma } from '../lib/db.js';
+export async function internalRoutes(fastify) {
+    const io = fastify.io;
+    // POST /internal/tabs/:tab_id/status
+    fastify.post('/internal/tabs/:tab_id/status', async (request, reply) => {
+        const { tab_id } = request.params;
+        const { status, todos } = request.body;
+        if (!status) {
+            return reply.status(400).send({ error: 'status is required' });
+        }
+        const result = await prisma.tab.updateMany({
+            where: { tabId: tab_id },
+            data: {
+                status,
+                ...(todos !== undefined && { todos: JSON.stringify(todos) }),
+            },
+        });
+        if (result.count === 0) {
+            return reply.status(404).send({ error: 'Tab not found' });
+        }
+        return reply.status(200).send({ data: { tabId: tab_id, status } });
+    });
+    // GET /internal/tabs/:tab_id/todos
+    fastify.get('/internal/tabs/:tab_id/todos', async (request, reply) => {
+        const { tab_id } = request.params;
+        try {
+            const tab = await prisma.tab.findUnique({
+                where: { tabId: tab_id },
+                select: { todos: true },
+            });
+            if (!tab) {
+                return reply.status(404).send({ error: 'Tab not found' });
+            }
+            const todos = tab.todos ? JSON.parse(tab.todos) : [];
+            return reply.status(200).send({ data: { todos } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'Failed to get tab todos');
+            return reply.status(500).send({ error: 'Failed to get todos' });
+        }
+    });
+    // POST /internal/emit-status
+    fastify.post('/internal/emit-status', async (request, reply) => {
+        const { sessionId, status } = request.body;
+        if (!sessionId || !status) {
+            return reply.status(400).send({ error: 'sessionId and status are required' });
+        }
+        const room = `tab:${sessionId}`;
+        io.to(room).emit('status-changed', { sessionId, status });
+        return reply.status(200).send({ ok: true });
+    });
+}

package/dist/server/routes/mcp.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function mcpRoutes(fastify: FastifyInstance): Promise<void>;

package/dist/server/routes/mcp.js

@@ -1,11 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mcpRoutes = mcpRoutes;
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const task_service_js_1 = require("../../src/lib/services/task-service.js");
-/** SSEセッションIDをキーにしたtransportのMap */
+import { randomUUID } from 'node:crypto';
+import { prisma } from '../lib/db.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { listTasks, getTask, createTask, updateTask, deleteTask, listRepos, ensureDefaultWorktree, TaskServiceError, } from '../lib/services/task-service.js';
+/** セッションIDをキーにしたtransportのMap */
 const transports = new Map();
 /** タスク指定パラメータの共通inputSchema */
 const taskIdentifierProperties = {
@@ -47,9 +46,9 @@ function checkTypos(args) {
 }
 /** MCPサーバーインスタンスを作成して全toolsを登録する */
 function createMcpServer(io) {
-    const server = new index_js_1.Server({ name: 'tsunagi', version: '1.0.0' }, { capabilities: { tools: {} } });
+    const server = new Server({ name: 'tsunagi', version: '1.0.0' }, { capabilities: { tools: {} } });
     // tools一覧
-    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: [
             {
                 name: 'tsunagi_list_tasks',
@@ -195,7 +194,7 @@ function createMcpServer(io) {
         ],
     }));
     // tool呼び出し
-    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
         try {
             // タスクツールの typo 検出（schema validation が skip された場合のフォールバック）
@@ -208,7 +207,7 @@ function createMcpServer(io) {
             switch (name) {
                 case 'tsunagi_list_tasks': {
                     const { owner, repo, status } = (args ?? {});
-                    const tasks = await (0, task_service_js_1.listTasks)({
+                    const tasks = await listTasks({
                         owner,
                         repo,
                         status: status,
@@ -216,12 +215,12 @@ function createMcpServer(io) {
                     return { content: [{ type: 'text', text: JSON.stringify(tasks, null, 2) }] };
                 }
                 case 'tsunagi_get_task': {
-                    const task = await (0, task_service_js_1.getTask)(args);
+                    const task = await getTask(args);
                     return { content: [{ type: 'text', text: JSON.stringify(task, null, 2) }] };
                 }
                 case 'tsunagi_create_task': {
                     const { owner, repo, title, description, effort, order, status, branch, baseBranch } = (args ?? {});
-                    const result = await (0, task_service_js_1.createTask)({
+                    const result = await createTask({
                         owner,
                         repo,
                         title,
@@ -236,7 +235,7 @@ function createMcpServer(io) {
                 }
                 case 'tsunagi_update_task': {
                     const { id, session_id, cwd, title, description, status, effort, order, baseBranch, pullRequestUrl, } = (args ?? {});
-                    const updated = await (0, task_service_js_1.updateTask)({ id, session_id, cwd }, {
+                    const updated = await updateTask({ id, session_id, cwd }, {
                         ...(title !== undefined ? { title } : {}),
                         ...(description !== undefined ? { description } : {}),
                         ...(status !== undefined
@@ -250,28 +249,28 @@ function createMcpServer(io) {
                     return { content: [{ type: 'text', text: JSON.stringify(updated, null, 2) }] };
                 }
                 case 'tsunagi_delete_task': {
-                    const task = await (0, task_service_js_1.deleteTask)(args, { io });
+                    const task = await deleteTask(args, { io });
                     return { content: [{ type: 'text', text: JSON.stringify(task ?? 'Task deleted') }] };
                 }
                 case 'tsunagi_list_repos': {
-                    const repos = await (0, task_service_js_1.listRepos)();
+                    const repos = await listRepos();
                     return { content: [{ type: 'text', text: JSON.stringify(repos, null, 2) }] };
                 }
                 case 'tsunagi_get_tab_todos': {
                     const { tabId } = (args ?? {});
                     try {
-                        const res = await fetch(`http://localhost:2791/api/internal/tabs/${tabId}/todos`);
-                        if (!res.ok) {
+                        const tab = await prisma.tab.findUnique({ where: { tabId } });
+                        if (!tab) {
                             return {
                                 content: [{ type: 'text', text: JSON.stringify({ tabId, todos: [] }, null, 2) }],
                             };
                         }
-                        const data = (await res.json());
+                        const todos = JSON.parse(tab.todos ?? '[]');
                         return {
                             content: [
                                 {
                                     type: 'text',
-                                    text: JSON.stringify({ tabId, todos: data.data.todos }, null, 2),
+                                    text: JSON.stringify({ tabId, todos }, null, 2),
                                 },
                             ],
                         };
@@ -284,7 +283,7 @@ function createMcpServer(io) {
                 }
                 case 'tsunagi_ensure_default_worktree': {
                     const { owner, repo } = (args ?? {});
-                    const result = await (0, task_service_js_1.ensureDefaultWorktree)(owner, repo);
+                    const result = await ensureDefaultWorktree(owner, repo);
                     return {
                         content: [
                             {
@@ -310,7 +309,7 @@ function createMcpServer(io) {
                 content: [
                     {
                         type: 'text',
-                        text: error instanceof task_service_js_1.TaskServiceError ? error.message : String(error),
+                        text: error instanceof TaskServiceError ? error.message : String(error),
                     },
                 ],
                 isError: true,
@@ -319,31 +318,55 @@ function createMcpServer(io) {
     });
     return server;
 }
-async function mcpRoutes(fastify) {
+export async function mcpRoutes(fastify) {
     const io = fastify.io;
-    // GET /mcp - SSE接続エンドポイント（MCP over SSE）
+    // POST /mcp - セッション初期化またはメッセージ処理
+    fastify.post('/mcp', async (request, reply) => {
+        const sessionId = request.headers['mcp-session-id'];
+        if (sessionId) {
+            // 既存セッション: ルーティング
+            const transport = transports.get(sessionId);
+            if (!transport) {
+                return reply.status(404).send({ error: `Session not found: ${sessionId}` });
+            }
+            await reply.hijack();
+            await transport.handleRequest(request.raw, reply.raw, request.body);
+        }
+        else {
+            // 新規セッション初期化
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+                onsessioninitialized: (id) => {
+                    transports.set(id, transport);
+                },
+                onsessionclosed: (id) => {
+                    transports.delete(id);
+                },
+            });
+            const server = createMcpServer(io);
+            await server.connect(transport);
+            await reply.hijack();
+            await transport.handleRequest(request.raw, reply.raw, request.body);
+        }
+    });
+    // GET /mcp - SSEストリーム（既存セッション用）
     fastify.get('/mcp', async (request, reply) => {
-        const res = reply.raw;
-        const transport = new sse_js_1.SSEServerTransport('/mcp', res);
-        transports.set(transport.sessionId, transport);
-        res.on('close', () => {
-            transports.delete(transport.sessionId);
-        });
+        const sessionId = request.headers['mcp-session-id'];
+        if (!sessionId || !transports.has(sessionId)) {
+            return reply.status(400).send({ error: 'Invalid or missing mcp-session-id header' });
+        }
+        const transport = transports.get(sessionId);
         await reply.hijack();
-        const server = createMcpServer(io);
-        await server.connect(transport);
+        await transport.handleRequest(request.raw, reply.raw);
     });
-    // POST /mcp - tool呼び出しエンドポイント
-    fastify.post('/mcp', async (request, reply) => {
-        const sessionId = request.query['sessionId'];
-        if (!sessionId) {
-            return reply.status(400).send({ error: 'sessionId query parameter required' });
+    // DELETE /mcp - セッション終了
+    fastify.delete('/mcp', async (request, reply) => {
+        const sessionId = request.headers['mcp-session-id'];
+        if (!sessionId || !transports.has(sessionId)) {
+            return reply.status(400).send({ error: 'Invalid or missing mcp-session-id header' });
         }
         const transport = transports.get(sessionId);
-        if (!transport) {
-            return reply.status(404).send({ error: `Session not found: ${sessionId}` });
-        }
-        await transport.handlePostMessage(request.raw, reply.raw, request.body);
         await reply.hijack();
+        await transport.handleRequest(request.raw, reply.raw);
     });
 }

package/dist/server/routes/onboarding.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function onboardingRoutes(fastify: FastifyInstance): Promise<void>;

package/dist/server/routes/onboarding.js

@@ -0,0 +1,15 @@
+import { getEnv } from '../lib/repositories/environment.js';
+export async function onboardingRoutes(fastify) {
+    // GET /onboarding/status
+    fastify.get('/onboarding/status', async (_request, reply) => {
+        try {
+            const globalEnv = await getEnv('global');
+            const hasGlobalToken = Boolean(globalEnv.ANTHROPIC_API_KEY || globalEnv.CLAUDE_CODE_OAUTH_TOKEN);
+            return reply.status(200).send({ data: { completed: hasGlobalToken, hasGlobalToken } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'GET /onboarding/status error');
+            return reply.status(500).send({ error: 'Failed to fetch onboarding status' });
+        }
+    });
+}

package/dist/server/routes/planner.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function plannerRoutes(fastify: FastifyInstance): Promise<void>;