@kanf/wema-kake 0.0.0-stage → 0.1.1

package/dist/lib/worker/config.js

@@ -0,0 +1,23 @@
+// パッケージの利用側が渡す設定と、Worker が受け取るバインディング。どちらも、パッケージの
+// 入口（src/index.ts）から型として公開する。**公開した後は約束になる**ので、項目を落とすことと、
+// 既定の値を変えることは、破壊的変更として扱う（docs/package.md の「互換の決まり」）。
+import { isLang } from '../shared/i18n';
+import { DEFAULT_SITE } from '../shared/site';
+/**
+ * 既定の値を埋める。不正な値は、Worker の起動時（モジュールの読み込み時）に例外にする。
+ * リクエストを受けてから気付く形にしない
+ */
+export function resolveConfig(config = {}) {
+    const { siteName = DEFAULT_SITE.siteName, defaultLang = DEFAULT_SITE.defaultLang, mcp = true, firstPage = true } = config;
+    if (typeof siteName !== 'string' || siteName.trim() === '') {
+        throw new TypeError('wema-kake: siteName must be a non-empty string');
+    }
+    if (!isLang(defaultLang))
+        throw new TypeError(`wema-kake: unknown defaultLang: ${String(defaultLang)}`);
+    // JavaScript から渡されると型の検査を通らないので、'false' のような文字列をここで断る（真として扱われる）
+    for (const [key, value] of Object.entries({ mcp, firstPage })) {
+        if (typeof value !== 'boolean')
+            throw new TypeError(`wema-kake: ${key} must be a boolean`);
+    }
+    return { siteName, defaultLang, mcp, firstPage };
+}

package/dist/lib/worker/first-page.d.ts

@@ -0,0 +1,10 @@
+import type { Lang } from '../shared/i18n';
+import type { WemaKakeEnv } from './config';
+/**
+ * まだ作っていなければ、最初のページを作る。作ったら true。
+ * 一覧が空のときにだけ呼ぶ（呼ぶたびに D1 へ書き込みを試みるため）。
+ *
+ * `lang` は、一覧を開いた人の画面の言語。その言語の表示名と付箋で作る。作った後は、ふつうの
+ * ページなので、言語を切り替えても変わらない
+ */
+export declare function createFirstPage(env: WemaKakeEnv, lang: Lang): Promise<boolean>;

package/dist/lib/worker/first-page.js

@@ -0,0 +1,30 @@
+import { FIRST_PAGE_SLUG, firstPageTitle, guideBoard } from '../shared/guide';
+const KEY = 'first_page';
+/**
+ * まだ作っていなければ、最初のページを作る。作ったら true。
+ * 一覧が空のときにだけ呼ぶ（呼ぶたびに D1 へ書き込みを試みるため）。
+ *
+ * `lang` は、一覧を開いた人の画面の言語。その言語の表示名と付箋で作る。作った後は、ふつうの
+ * ページなので、言語を切り替えても変わらない
+ */
+export async function createFirstPage(env, lang) {
+    // 記録を先に書く。同時に届いたリクエストのうち、書けた 1 つだけが作る
+    const claimed = await env.DB.prepare(`INSERT OR IGNORE INTO settings (key, value) VALUES (?, 'created')`)
+        .bind(KEY)
+        .run();
+    if (claimed.meta.changes === 0)
+        return false;
+    try {
+        const { notes, edges } = guideBoard('first', lang);
+        const deltas = [
+            ...notes.map((note) => ({ type: 'note:create', note })),
+            ...edges.map((edge) => ({ type: 'edge:create', edge })),
+        ];
+        return await env.PAGE.getByName(FIRST_PAGE_SLUG).createWithContent(firstPageTitle(lang), deltas);
+    }
+    catch (e) {
+        // 作れなかったら、記録を消して、次に一覧を開いたときにやり直す
+        await env.DB.prepare(`DELETE FROM settings WHERE key = ?`).bind(KEY).run();
+        throw e;
+    }
+}

package/dist/lib/worker/images.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+import type { AuthEnv } from './access';
+export declare const images: Hono<AuthEnv, import("hono/types").BlankSchema, "/">;

package/dist/lib/worker/images.js

@@ -0,0 +1,54 @@
+// 付箋に貼る画像。R2 に置き、text には URL（/img/<key>）だけを入れる。
+import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+/** 受け付ける形式。SVG はスクリプトを含められるので受け付けない */
+const EXTENSIONS = {
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'image/gif': 'gif',
+    'image/webp': 'webp',
+    'image/avif': 'avif',
+};
+const KEY_RE = new RegExp(`^[0-9a-f-]{36}\\.(${Object.values(EXTENSIONS).join('|')})$`);
+export const images = new Hono();
+/** 本文に画像のバイト列、Content-Type に画像の形式を入れて送る */
+images.post('/api/images', 
+// Content-Length のない送信でも、上限を超える本文をメモリに載せない
+bodyLimit({
+    maxSize: MAX_IMAGE_BYTES,
+    onError: (c) => c.json({ error: 'image too large' }, 413),
+}), async (c) => {
+    const contentType = c.req.header('Content-Type')?.split(';')[0].trim().toLowerCase() ?? '';
+    const ext = EXTENSIONS[contentType];
+    if (!ext)
+        return c.json({ error: 'unsupported image type' }, 415);
+    const body = await c.req.arrayBuffer();
+    if (body.byteLength === 0)
+        return c.json({ error: 'empty image' }, 400);
+    const key = `${crypto.randomUUID()}.${ext}`;
+    await c.env.IMAGES.put(key, body, {
+        httpMetadata: { contentType },
+        customMetadata: { uploadedBy: c.get('actor') },
+    });
+    return c.json({ url: `/img/${key}` }, 201);
+});
+images.get('/img/:key', async (c) => {
+    const key = c.req.param('key');
+    if (!KEY_RE.test(key))
+        return c.notFound();
+    const object = await c.env.IMAGES.get(key);
+    if (!object)
+        return c.notFound();
+    return new Response(object.body, {
+        headers: {
+            'Content-Type': object.httpMetadata?.contentType ?? 'application/octet-stream',
+            ETag: object.httpEtag,
+            // キーは内容ごとに新しく作るので、同じ URL の内容は変わらない
+            'Cache-Control': 'private, max-age=31536000, immutable',
+            // 申告された形式と中身が違っても、ブラウザに HTML などとして解釈させない
+            'X-Content-Type-Options': 'nosniff',
+            'Content-Security-Policy': "default-src 'none'; sandbox",
+        },
+    });
+});

package/dist/lib/worker/index.d.ts

@@ -0,0 +1,8 @@
+import { Hono } from 'hono';
+import { type AuthEnv } from './access';
+import { type WemaKakeConfig } from './config';
+/**
+ * Worker のアプリを組み立てる。パッケージの入口（src/index.ts）の `createWemaKake` が呼ぶ。
+ * テストは、これを直接呼んで `app.request` を使う。設定の不正は、ここで例外にする
+ */
+export declare function createApp(options?: WemaKakeConfig): Hono<AuthEnv, import("hono/types").BlankSchema, "/">;

package/dist/lib/worker/index.js

@@ -0,0 +1,72 @@
+import { Hono } from 'hono';
+import { requireAccess } from './access';
+import { assetServer } from './assets';
+import { resolveConfig } from './config';
+import { images } from './images';
+import { handleMcp } from './mcp/server';
+import { ACTOR_HEADER, AUTH_EXPIRES_HEADER } from './page-do';
+import { pagesApi, validSlug } from './pages-api';
+/**
+ * Worker のアプリを組み立てる。パッケージの入口（src/index.ts）の `createWemaKake` が呼ぶ。
+ * テストは、これを直接呼んで `app.request` を使う。設定の不正は、ここで例外にする
+ */
+export function createApp(options = {}) {
+    const config = resolveConfig(options);
+    const serveAsset = assetServer(config);
+    const app = new Hono();
+    app.use(async (c, next) => {
+        c.set('config', config);
+        await next();
+    });
+    // このアプリに届くリクエストはすべて認証を通す（画面のアセットも、末尾のルートから返すので、
+    // 認証の後になる）。`/mcp` は MCP のクライアント（agent）だけ、それ以外は Access にログインした
+    // 人だけを通す。
+    //
+    // MCP のクライアントは、Access の Managed OAuth で認可される。クライアントの登録、認可の画面、
+    // トークンの発行は Access が行い、Worker には届かない。
+    // **`/mcp` は、下の `app.use(requireAccess('user'))` より前に置くこと。** ハンドラが応答を返すので、
+    // 人向けの認証には進まない。後ろに置くと、agent が人向けの認証で断られる
+    // 無効なら、人向けの認証より前で 404 を返す（後ろに落とすと、agent のトークンが人向けの認証で 403 になる）
+    if (config.mcp) {
+        app.all('/mcp', requireAccess('agent'), (c) => handleMcp(c.req.raw, c.env, c.executionCtx, c.get('actor')));
+    }
+    else {
+        app.all('/mcp', (c) => c.notFound());
+    }
+    app.use(requireAccess('user'));
+    // Access の Cookie は他サイトからのリクエストにも付く。状態を変えるリクエストと WebSocket の
+    // 接続要求（同一オリジンの制約を受けない）は、他のオリジンからのものを断る
+    app.use(async (c, next) => {
+        const method = c.req.method;
+        const guarded = (method !== 'GET' && method !== 'HEAD') || c.req.header('Upgrade') === 'websocket';
+        const origin = c.req.header('Origin');
+        if (guarded && origin && origin !== new URL(c.req.url).origin) {
+            return c.json({ error: 'forbidden origin' }, 403);
+        }
+        await next();
+    });
+    app.route('/api', pagesApi);
+    app.route('/', images);
+    app.get('/ws/:slug', validSlug, async (c) => {
+        if (c.req.header('Upgrade') !== 'websocket') {
+            return c.json({ error: 'expected websocket' }, 426);
+        }
+        // クライアントが同名のヘッダーを付けてきても、認証結果で上書きする
+        const headers = new Headers(c.req.raw.headers);
+        headers.set(ACTOR_HEADER, c.get('actor'));
+        const expiresAt = c.get('authExpiresAt');
+        if (expiresAt === undefined)
+            headers.delete(AUTH_EXPIRES_HEADER);
+        else
+            headers.set(AUTH_EXPIRES_HEADER, String(expiresAt));
+        return c.env.PAGE.getByName(c.req.param('slug')).fetch(new Request(c.req.raw, { headers }));
+    });
+    // API のパスで、上のどのルートにも合わなかったもの。画面（index.html）ではなく JSON の 404 にする。
+    // **API のパスの最初の部分を足したら、ここにも足す**（足さないと、そのパスの「ない」が画面の 200 になる）
+    for (const path of ['/api/*', '/ws/*', '/img/*', '/mcp', '/mcp/*'])
+        app.all(path, (c) => c.notFound());
+    // 残りの GET と HEAD は、画面のアセット（`run_worker_first: true` なので、静的ファイルの要求もここに来る）
+    app.on(['GET', 'HEAD'], '*', (c) => serveAsset(c.req.raw, c.env));
+    app.notFound((c) => c.json({ error: 'not found' }, 404));
+    return app;
+}

package/dist/lib/worker/indexer.d.ts

@@ -0,0 +1,42 @@
+import type { WemaNote } from '../shared/delta';
+export interface PageContent {
+    plainText: string;
+    /** このページからリンクしているページのスラッグ */
+    links: string[];
+}
+/** 全付箋の text（サニタイズ済みの HTML）から、検索用のテキストとページ間リンクを作る */
+export declare function buildPageContent(slug: string, noteTexts: string[], siteOrigin: string | undefined): Promise<PageContent>;
+/** 検索とリンクに関わる内容が前回の反映から変わったかを比べるための値 */
+export declare function contentHash(title: string | null, content: PageContent): Promise<string>;
+/** 検索とリンクのほかに、ページの行へ書く値 */
+export interface PageRow {
+    title: string | null;
+    /** ページの色。付けていなければ null */
+    color: string | null;
+    /** 親ページのスラッグ。ルートのページなら null */
+    parent: string | null;
+    /** 付箋の配置（buildLayout の結果） */
+    layout: string;
+    noteCount: number;
+    now: number;
+}
+/**
+ * 付箋の配置を、小さな JSON にする。親ページの画面が、子ページの付箋の上に、子ページの
+ * 配置を簡易に再現するのに使う。1 枚は `[x, y, 幅, 高さ, 色]`。本文と接続線は入れない
+ */
+export declare function buildLayout(notes: Pick<WemaNote, 'x' | 'y' | 'width' | 'height' | 'color'>[]): string;
+/**
+ * 検索とリンク以外の値（付箋の数、更新日時、親、配置）だけを書く。付箋の移動や色の変更のように、
+ * 検索とリンクに関わる内容が変わっていないときに使う。ページの行がなければ false を返す
+ * （そのときは writePage で作る）。
+ */
+export declare function touchPage(db: D1Database, slug: string, row: PageRow): Promise<boolean>;
+/** 索引の上で `slug` を親としているページ */
+export declare function indexedChildren(db: D1Database, slug: string): Promise<string[]>;
+/**
+ * 1 ページ分の索引を消す。他のページからこのページへのリンクは残す
+ * （リンク元の付箋にはリンクが残っていて、一覧では未作成のページとして出る）
+ */
+export declare function removePage(db: D1Database, slug: string): Promise<void>;
+/** 1 ページ分の索引を入れ替える。1 つのトランザクションで実行する */
+export declare function writePage(db: D1Database, slug: string, content: PageContent, row: PageRow): Promise<void>;

package/dist/lib/worker/indexer.js

@@ -0,0 +1,93 @@
+import { extractContent, linkedSlug } from './plain-text';
+/** pages.plain_text の上限（文字数）。D1 の 1 行の上限に収め、検索の対象としても十分な量にする */
+const MAX_PLAIN_TEXT_LENGTH = 300_000;
+const MAX_LINKS = 500;
+/** 全付箋の text（サニタイズ済みの HTML）から、検索用のテキストとページ間リンクを作る */
+export async function buildPageContent(slug, noteTexts, siteOrigin) {
+    const texts = [];
+    let length = 0;
+    const links = new Set();
+    for (const html of noteTexts) {
+        const { text, hrefs } = await extractContent(html);
+        if (text && length < MAX_PLAIN_TEXT_LENGTH) {
+            texts.push(text);
+            length += text.length + 1;
+        }
+        for (const href of hrefs) {
+            const to = linkedSlug(href, siteOrigin);
+            if (to && to !== slug && links.size < MAX_LINKS)
+                links.add(to);
+        }
+    }
+    return {
+        plainText: texts.join('\n').slice(0, MAX_PLAIN_TEXT_LENGTH),
+        links: [...links].sort(),
+    };
+}
+/** 検索とリンクに関わる内容が前回の反映から変わったかを比べるための値 */
+export async function contentHash(title, content) {
+    const bytes = new TextEncoder().encode(JSON.stringify([title, content.plainText, content.links]));
+    const digest = await crypto.subtle.digest('SHA-256', bytes);
+    return btoa(String.fromCharCode(...new Uint8Array(digest)));
+}
+/** 配置に入れる付箋の数の上限 */
+const MAX_LAYOUT_NOTES = 200;
+/**
+ * 付箋の配置を、小さな JSON にする。親ページの画面が、子ページの付箋の上に、子ページの
+ * 配置を簡易に再現するのに使う。1 枚は `[x, y, 幅, 高さ, 色]`。本文と接続線は入れない
+ */
+export function buildLayout(notes) {
+    return JSON.stringify(notes
+        .slice(0, MAX_LAYOUT_NOTES)
+        .map((n) => [Math.round(n.x), Math.round(n.y), Math.round(n.width), Math.round(n.height), n.color]));
+}
+/**
+ * 検索とリンク以外の値（付箋の数、更新日時、親、配置）だけを書く。付箋の移動や色の変更のように、
+ * 検索とリンクに関わる内容が変わっていないときに使う。ページの行がなければ false を返す
+ * （そのときは writePage で作る）。
+ */
+export async function touchPage(db, slug, row) {
+    const result = await db
+        .prepare(`UPDATE pages SET note_count = ?, updated_at = ?, parent = ?, layout = ?, color = ? WHERE name = ?`)
+        .bind(row.noteCount, row.now, row.parent, row.layout, row.color, slug)
+        .run();
+    return result.meta.changes > 0;
+}
+/** 索引の上で `slug` を親としているページ */
+export async function indexedChildren(db, slug) {
+    const { results } = await db.prepare(`SELECT name FROM pages WHERE parent = ?`).bind(slug).all();
+    return results.map((row) => row.name);
+}
+/**
+ * 1 ページ分の索引を消す。他のページからこのページへのリンクは残す
+ * （リンク元の付箋にはリンクが残っていて、一覧では未作成のページとして出る）
+ */
+export async function removePage(db, slug) {
+    await db.batch([
+        db.prepare(`DELETE FROM pages_fts WHERE rowid = (SELECT id FROM pages WHERE name = ?)`).bind(slug),
+        db.prepare(`DELETE FROM links WHERE from_page = ?`).bind(slug),
+        db.prepare(`DELETE FROM pages WHERE name = ?`).bind(slug),
+        db.prepare(`DELETE FROM bookmarks WHERE page = ?`).bind(slug),
+    ]);
+}
+/** 1 ページ分の索引を入れ替える。1 つのトランザクションで実行する */
+export async function writePage(db, slug, content, row) {
+    await db.batch([
+        db
+            .prepare(`INSERT INTO pages (name, title, plain_text, note_count, updated_at, parent, layout, color)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT (name) DO UPDATE SET title = excluded.title, plain_text = excluded.plain_text,
+           note_count = excluded.note_count, updated_at = excluded.updated_at,
+           parent = excluded.parent, layout = excluded.layout, color = excluded.color`)
+            .bind(slug, row.title, content.plainText, row.noteCount, row.now, row.parent, row.layout, row.color),
+        db.prepare(`DELETE FROM links WHERE from_page = ?`).bind(slug),
+        db
+            .prepare(`INSERT INTO links (from_page, to_page) SELECT ?, value FROM json_each(?)`)
+            .bind(slug, JSON.stringify(content.links)),
+        db.prepare(`DELETE FROM pages_fts WHERE rowid = (SELECT id FROM pages WHERE name = ?)`).bind(slug),
+        db
+            .prepare(`INSERT INTO pages_fts (rowid, title, plain_text)
+         SELECT id, coalesce(title, ''), plain_text FROM pages WHERE name = ?`)
+            .bind(slug),
+    ]);
+}

package/dist/lib/worker/mcp/board-access.d.ts

@@ -0,0 +1,28 @@
+import type { OpSummary, RevertOutcome } from '../../shared/api';
+import type { HistoryDelta } from '../../shared/delta';
+import { type ApplyOutcome, type BoardAccess, type BoardState } from '../../shared/tools';
+import type { WemaKakeEnv } from '../config';
+export declare class ServerBoardAccess implements BoardAccess {
+    private readonly env;
+    private readonly actor;
+    /**
+     * @param actor 変更の主体（'agent:<client>'）。認証結果から決めたものを渡す
+     */
+    constructor(env: WemaKakeEnv, actor: string);
+    private page;
+    listPages(options: {
+        updatedAfter?: number;
+        limit?: number;
+    }): Promise<import("../../shared/tools").PageInfo[]>;
+    searchPages(query: string): Promise<{
+        name: string;
+        title: string | null;
+        parent: string | null;
+        snippet: string | undefined;
+    }[]>;
+    readBoard(slug: string): Promise<BoardState | null>;
+    plainText(html: string): Promise<string>;
+    apply(slug: string, deltas: HistoryDelta[], summary: string): Promise<ApplyOutcome>;
+    ownOps(slug: string): Promise<OpSummary[]>;
+    revert(slug: string, seq: number, summary: string): Promise<RevertOutcome>;
+}

package/dist/lib/worker/mcp/board-access.js

@@ -0,0 +1,67 @@
+import { ToolError } from '../../shared/tools';
+import { listPages, searchPages } from '../page-queries';
+import { extractContent } from '../plain-text';
+/** ops に記録する clientId。MCP にはブラウザのような接続ごとの id がない */
+const MCP_CLIENT_ID = 'mcp';
+export class ServerBoardAccess {
+    env;
+    actor;
+    /**
+     * @param actor 変更の主体（'agent:<client>'）。認証結果から決めたものを渡す
+     */
+    constructor(env, actor) {
+        this.env = env;
+        this.actor = actor;
+    }
+    page(slug) {
+        return this.env.PAGE.getByName(slug);
+    }
+    listPages(options) {
+        return listPages(this.env.DB, options);
+    }
+    async searchPages(query) {
+        const hits = await searchPages(this.env.DB, query);
+        if (hits === null)
+            throw new ToolError('invalid query');
+        return hits.map(({ name, title, parent, snippet }) => ({ name, title, parent, snippet }));
+    }
+    async readBoard(slug) {
+        return this.page(slug).getBoardState();
+    }
+    async plainText(html) {
+        // ページへのリンクは、書くときと同じ書式（[[slug]]）で残す
+        return (await extractContent(html, { siteOrigin: this.env.SITE_ORIGIN })).text;
+    }
+    async apply(slug, deltas, summary) {
+        const result = await this.page(slug).applyOps({
+            actor: this.actor,
+            clientId: MCP_CLIENT_ID,
+            opId: crypto.randomUUID(),
+            deltas,
+            summary,
+            // 読んでから適用するまでの間にページが削除されていても、作り直さない
+            mustExist: true,
+        });
+        if (!result.ok)
+            return { ok: false, reason: result.reason };
+        // すべてのデルタが捨てられた場合、seq は進んでいない（直前の別の操作の番号が入っている）
+        return { ok: true, seq: result.deltas.length > 0 ? result.seq : null };
+    }
+    async ownOps(slug) {
+        return this.page(slug).listOps({ actor: this.actor });
+    }
+    async revert(slug, seq, summary) {
+        const result = await this.page(slug).revert({
+            seq,
+            actor: this.actor,
+            clientId: MCP_CLIENT_ID,
+            opId: crypto.randomUUID(),
+            // agent が取り消せるのは、自分の操作だけ
+            ownOnly: true,
+            summary,
+        });
+        if (!result.ok)
+            throw new ToolError(result.reason);
+        return { seq: result.seq, applied: result.applied, skipped: result.skipped };
+    }
+}

package/dist/lib/worker/mcp/server.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from '@modelcontextprotocol/server';
+import { type BoardAccess } from '../../shared/tools';
+import type { WemaKakeEnv } from '../config';
+export declare function createMcpServer(access: BoardAccess): McpServer;
+/**
+ * `/mcp` のハンドラ。認証は呼び出し側（`src/worker/index.ts`）が済ませていて、
+ * そこで決めた変更の主体（`agent:<client>`）を受け取る
+ */
+export declare function handleMcp(request: Request, env: WemaKakeEnv, ctx: ExecutionContext, actor: string): Promise<Response>;

package/dist/lib/worker/mcp/server.js

@@ -0,0 +1,39 @@
+// リモート MCP サーバー。ツールの定義と実装は src/shared/tools.ts にあり、ここでは MCP の
+// サーバーに登録して、結果を MCP の形にするだけ。
+import { McpServer } from '@modelcontextprotocol/server';
+import { createMcpHandler } from 'agents/mcp/server';
+import { TOOLS, ToolError } from '../../shared/tools';
+import { ServerBoardAccess } from './board-access';
+export function createMcpServer(access) {
+    const server = new McpServer({ name: 'wema-kake', version: '0.1.0' });
+    for (const tool of TOOLS) {
+        server.registerTool(tool.name, {
+            description: tool.description,
+            inputSchema: tool.input,
+            annotations: { readOnlyHint: tool.readOnly },
+        }, async (input) => {
+            try {
+                // 入力は、MCP のサーバーが tool.input で検証済み
+                const result = await tool.run(access, input);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (e) {
+                // 入力や状態の問題は、LLM が読んで直せるように結果として返す
+                if (e instanceof ToolError) {
+                    return { isError: true, content: [{ type: 'text', text: e.message }] };
+                }
+                throw e;
+            }
+        });
+    }
+    return server;
+}
+/**
+ * `/mcp` のハンドラ。認証は呼び出し側（`src/worker/index.ts`）が済ませていて、
+ * そこで決めた変更の主体（`agent:<client>`）を受け取る
+ */
+export function handleMcp(request, env, ctx, actor) {
+    const access = new ServerBoardAccess(env, actor);
+    // リクエストごとにサーバーを作る（MCP のサーバーは、同時に走るリクエストで共有できない）
+    return createMcpHandler(() => createMcpServer(access))(request, env, ctx);
+}