@kajidog/connpass-mcp-server 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,189 +1,4756 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const connpass_api_client_1 = require("@kajidog/connpass-api-client");
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const apps_sdk_js_1 = require("./apps-sdk.js");
-const config_js_1 = require("./config.js");
-const index_js_2 = require("./tools/index.js");
-const http_js_1 = require("./transports/http.js");
-const sse_js_1 = require("./transports/sse.js");
-const index_js_3 = require("./widgets/index.js");
-const rateLimitEnabled = (0, config_js_1.getRateLimitEnabled)();
-const rateLimitDelay = (0, config_js_1.getRateLimitDelayMs)();
-const envApiKey = process.env.CONNPASS_API_KEY;
-if (!envApiKey) {
-    console.warn("[mcp-server] CONNPASS_API_KEY not set. Using dummy-key (Connpass API will reject most requests)");
-}
-else {
-    console.log(`[mcp-server] CONNPASS_API_KEY detected (length: ${envApiKey.length}).`);
-}
-const connpassClient = new connpass_api_client_1.ConnpassClient({
-    apiKey: envApiKey || "dummy-key",
-    ...(rateLimitEnabled !== undefined ? { rateLimitEnabled } : {}),
-    ...(rateLimitDelay !== undefined ? { rateLimitDelay } : {}),
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/@hono+node-server@1.19.7_hono@4.11.3/node_modules/@hono/node-server/dist/index.mjs
+var dist_exports = {};
+__export(dist_exports, {
+  RequestError: () => RequestError,
+  createAdaptorServer: () => createAdaptorServer,
+  getRequestListener: () => getRequestListener,
+  serve: () => serve
 });
-function createConnpassServer() {
-    const appsSdkOutputEnabled = (0, config_js_1.isAppsSdkOutputEnabled)();
-    console.log(`[mcp-server] Apps SDK output ${appsSdkOutputEnabled ? "enabled" : "disabled"}.`);
-    const server = new index_js_1.Server({
-        name: "connpass-mcp-server",
-        version: "1.0.0",
-    }, {
-        capabilities: {
-            tools: {},
-            resources: {},
-            resourceTemplates: {},
-        },
-    });
-    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
-        return { tools: index_js_2.tools };
-    });
-    server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
-        const resources = (0, index_js_3.listResources)();
-        console.log("[mcp-server] list_resources", resources);
-        return { resources };
-    });
-    server.setRequestHandler(types_js_1.ListResourceTemplatesRequestSchema, async () => {
-        const templates = (0, index_js_3.listResourceTemplates)();
-        console.log("[mcp-server] list_resource_templates", templates);
-        return { resourceTemplates: templates };
-    });
-    server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
-        const content = (0, index_js_3.getResourceContent)(request.params.uri);
-        if (!content) {
-            throw new Error(`Unknown resource: ${request.params.uri}`);
-        }
-        const meta = Object.prototype.hasOwnProperty.call(content, "_meta")
-            ? content._meta
-            : undefined;
-        console.log("[mcp-server] read_resource", request.params.uri, meta);
-        return {
-            contents: [content],
-        };
+import { createServer as createServerHTTP } from "http";
+import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
+import { Http2ServerRequest } from "http2";
+import { Readable } from "stream";
+import crypto from "crypto";
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const cancel = (error) => {
+    reader.cancel(error).catch(() => {
     });
-    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+  };
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+  });
+  function handleStreamError(error) {
+    if (error) {
+      writable.destroy(error);
+    }
+  }
+  function onDrain() {
+    reader.read().then(flow, handleStreamError);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (!writable.write(value)) {
+        writable.once("drain", onDrain);
+      } else {
+        return reader.read().then(flow, handleStreamError);
+      }
+    } catch (e) {
+      handleStreamError(e);
+    }
+  }
+}
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
+var RequestError, toRequestError, GlobalRequest, Request2, newHeadersFromIncoming, wrapBodyStream, newRequestFromIncoming, getRequestCache, requestCache, incomingKey, urlKey, headersKey, abortControllerKey, getAbortController, requestPrototype, newRequest, responseCache, getResponseCache, cacheKey, GlobalResponse, Response2, buildOutgoingHttpHeaders, X_ALREADY_SENT, webFetch, outgoingEnded, handleRequestError, handleFetchError, handleResponseError, flushHeaders, responseViaCache, isPromise, responseViaResponseObject, getRequestListener, createAdaptorServer, serve;
+var init_dist = __esm({
+  "../../node_modules/.pnpm/@hono+node-server@1.19.7_hono@4.11.3/node_modules/@hono/node-server/dist/index.mjs"() {
+    "use strict";
+    RequestError = class extends Error {
+      constructor(message, options) {
+        super(message, options);
+        this.name = "RequestError";
+      }
+    };
+    toRequestError = (e) => {
+      if (e instanceof RequestError) {
+        return e;
+      }
+      return new RequestError(e.message, { cause: e });
+    };
+    GlobalRequest = global.Request;
+    Request2 = class extends GlobalRequest {
+      constructor(input, options) {
+        if (typeof input === "object" && getRequestCache in input) {
+          input = input[getRequestCache]();
+        }
+        if (typeof options?.body?.getReader !== "undefined") {
+          ;
+          options.duplex ??= "half";
+        }
+        super(input, options);
+      }
+    };
+    newHeadersFromIncoming = (incoming) => {
+      const headerRecord = [];
+      const rawHeaders = incoming.rawHeaders;
+      for (let i = 0; i < rawHeaders.length; i += 2) {
+        const { [i]: key, [i + 1]: value } = rawHeaders;
+        if (key.charCodeAt(0) !== /*:*/
+        58) {
+          headerRecord.push([key, value]);
+        }
+      }
+      return new Headers(headerRecord);
+    };
+    wrapBodyStream = /* @__PURE__ */ Symbol("wrapBodyStream");
+    newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+      const init = {
+        method,
+        headers,
+        signal: abortController.signal
+      };
+      if (method === "TRACE") {
+        init.method = "GET";
+        const req = new Request2(url, init);
+        Object.defineProperty(req, "method", {
+          get() {
+            return "TRACE";
+          }
+        });
+        return req;
+      }
+      if (!(method === "GET" || method === "HEAD")) {
+        if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
+          init.body = new ReadableStream({
+            start(controller) {
+              controller.enqueue(incoming.rawBody);
+              controller.close();
+            }
+          });
+        } else if (incoming[wrapBodyStream]) {
+          let reader;
+          init.body = new ReadableStream({
+            async pull(controller) {
+              try {
+                reader ||= Readable.toWeb(incoming).getReader();
+                const { done, value } = await reader.read();
+                if (done) {
+                  controller.close();
+                } else {
+                  controller.enqueue(value);
+                }
+              } catch (error) {
+                controller.error(error);
+              }
+            }
+          });
+        } else {
+          init.body = Readable.toWeb(incoming);
+        }
+      }
+      return new Request2(url, init);
+    };
+    getRequestCache = /* @__PURE__ */ Symbol("getRequestCache");
+    requestCache = /* @__PURE__ */ Symbol("requestCache");
+    incomingKey = /* @__PURE__ */ Symbol("incomingKey");
+    urlKey = /* @__PURE__ */ Symbol("urlKey");
+    headersKey = /* @__PURE__ */ Symbol("headersKey");
+    abortControllerKey = /* @__PURE__ */ Symbol("abortControllerKey");
+    getAbortController = /* @__PURE__ */ Symbol("getAbortController");
+    requestPrototype = {
+      get method() {
+        return this[incomingKey].method || "GET";
+      },
+      get url() {
+        return this[urlKey];
+      },
+      get headers() {
+        return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
+      },
+      [getAbortController]() {
+        this[getRequestCache]();
+        return this[abortControllerKey];
+      },
+      [getRequestCache]() {
+        this[abortControllerKey] ||= new AbortController();
+        return this[requestCache] ||= newRequestFromIncoming(
+          this.method,
+          this[urlKey],
+          this.headers,
+          this[incomingKey],
+          this[abortControllerKey]
+        );
+      }
+    };
+    [
+      "body",
+      "bodyUsed",
+      "cache",
+      "credentials",
+      "destination",
+      "integrity",
+      "mode",
+      "redirect",
+      "referrer",
+      "referrerPolicy",
+      "signal",
+      "keepalive"
+    ].forEach((k) => {
+      Object.defineProperty(requestPrototype, k, {
+        get() {
+          return this[getRequestCache]()[k];
+        }
+      });
+    });
+    ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+      Object.defineProperty(requestPrototype, k, {
+        value: function() {
+          return this[getRequestCache]()[k]();
+        }
+      });
+    });
+    Object.setPrototypeOf(requestPrototype, Request2.prototype);
+    newRequest = (incoming, defaultHostname) => {
+      const req = Object.create(requestPrototype);
+      req[incomingKey] = incoming;
+      const incomingUrl = incoming.url || "";
+      if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
+      (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+        if (incoming instanceof Http2ServerRequest) {
+          throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+        }
         try {
-            const { name, arguments: args } = request.params;
-            const result = await (0, index_js_2.handleToolCall)(name, args, connpassClient);
-            return (0, apps_sdk_js_1.buildCallToolResult)({
-                toolName: name,
-                result,
-                includeAppsSdkPayload: appsSdkOutputEnabled,
+          const url2 = new URL(incomingUrl);
+          req[urlKey] = url2.href;
+        } catch (e) {
+          throw new RequestError("Invalid absolute URL", { cause: e });
+        }
+        return req;
+      }
+      const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+      if (!host) {
+        throw new RequestError("Missing host header");
+      }
+      let scheme;
+      if (incoming instanceof Http2ServerRequest) {
+        scheme = incoming.scheme;
+        if (!(scheme === "http" || scheme === "https")) {
+          throw new RequestError("Unsupported scheme");
+        }
+      } else {
+        scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+      }
+      const url = new URL(`${scheme}://${host}${incomingUrl}`);
+      if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+        throw new RequestError("Invalid host header");
+      }
+      req[urlKey] = url.href;
+      return req;
+    };
+    responseCache = /* @__PURE__ */ Symbol("responseCache");
+    getResponseCache = /* @__PURE__ */ Symbol("getResponseCache");
+    cacheKey = /* @__PURE__ */ Symbol("cache");
+    GlobalResponse = global.Response;
+    Response2 = class _Response {
+      #body;
+      #init;
+      [getResponseCache]() {
+        delete this[cacheKey];
+        return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+      }
+      constructor(body, init) {
+        let headers;
+        this.#body = body;
+        if (init instanceof _Response) {
+          const cachedGlobalResponse = init[responseCache];
+          if (cachedGlobalResponse) {
+            this.#init = cachedGlobalResponse;
+            this[getResponseCache]();
+            return;
+          } else {
+            this.#init = init.#init;
+            headers = new Headers(init.#init.headers);
+          }
+        } else {
+          this.#init = init;
+        }
+        if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+          headers ||= init?.headers || { "content-type": "text/plain; charset=UTF-8" };
+          this[cacheKey] = [init?.status || 200, body, headers];
+        }
+      }
+      get headers() {
+        const cache = this[cacheKey];
+        if (cache) {
+          if (!(cache[2] instanceof Headers)) {
+            cache[2] = new Headers(cache[2]);
+          }
+          return cache[2];
+        }
+        return this[getResponseCache]().headers;
+      }
+      get status() {
+        return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+      }
+      get ok() {
+        const status = this.status;
+        return status >= 200 && status < 300;
+      }
+    };
+    ["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
+      Object.defineProperty(Response2.prototype, k, {
+        get() {
+          return this[getResponseCache]()[k];
+        }
+      });
+    });
+    ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+      Object.defineProperty(Response2.prototype, k, {
+        value: function() {
+          return this[getResponseCache]()[k]();
+        }
+      });
+    });
+    Object.setPrototypeOf(Response2, GlobalResponse);
+    Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+    buildOutgoingHttpHeaders = (headers) => {
+      const res = {};
+      if (!(headers instanceof Headers)) {
+        headers = new Headers(headers ?? void 0);
+      }
+      const cookies = [];
+      for (const [k, v] of headers) {
+        if (k === "set-cookie") {
+          cookies.push(v);
+        } else {
+          res[k] = v;
+        }
+      }
+      if (cookies.length > 0) {
+        res["set-cookie"] = cookies;
+      }
+      res["content-type"] ??= "text/plain; charset=UTF-8";
+      return res;
+    };
+    X_ALREADY_SENT = "x-hono-already-sent";
+    webFetch = global.fetch;
+    if (typeof global.crypto === "undefined") {
+      global.crypto = crypto;
+    }
+    global.fetch = (info, init) => {
+      init = {
+        // Disable compression handling so people can return the result of a fetch
+        // directly in the loader without messing with the Content-Encoding header.
+        compress: false,
+        ...init
+      };
+      return webFetch(info, init);
+    };
+    outgoingEnded = /* @__PURE__ */ Symbol("outgoingEnded");
+    handleRequestError = () => new Response(null, {
+      status: 400
+    });
+    handleFetchError = (e) => new Response(null, {
+      status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
+    });
+    handleResponseError = (e, outgoing) => {
+      const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+      if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+        console.info("The user aborted a request.");
+      } else {
+        console.error(e);
+        if (!outgoing.headersSent) {
+          outgoing.writeHead(500, { "Content-Type": "text/plain" });
+        }
+        outgoing.end(`Error: ${err.message}`);
+        outgoing.destroy(err);
+      }
+    };
+    flushHeaders = (outgoing) => {
+      if ("flushHeaders" in outgoing && outgoing.writable) {
+        outgoing.flushHeaders();
+      }
+    };
+    responseViaCache = async (res, outgoing) => {
+      let [status, body, header] = res[cacheKey];
+      if (header instanceof Headers) {
+        header = buildOutgoingHttpHeaders(header);
+      }
+      if (typeof body === "string") {
+        header["Content-Length"] = Buffer.byteLength(body);
+      } else if (body instanceof Uint8Array) {
+        header["Content-Length"] = body.byteLength;
+      } else if (body instanceof Blob) {
+        header["Content-Length"] = body.size;
+      }
+      outgoing.writeHead(status, header);
+      if (typeof body === "string" || body instanceof Uint8Array) {
+        outgoing.end(body);
+      } else if (body instanceof Blob) {
+        outgoing.end(new Uint8Array(await body.arrayBuffer()));
+      } else {
+        flushHeaders(outgoing);
+        await writeFromReadableStream(body, outgoing)?.catch(
+          (e) => handleResponseError(e, outgoing)
+        );
+      }
+      ;
+      outgoing[outgoingEnded]?.();
+    };
+    isPromise = (res) => typeof res.then === "function";
+    responseViaResponseObject = async (res, outgoing, options = {}) => {
+      if (isPromise(res)) {
+        if (options.errorHandler) {
+          try {
+            res = await res;
+          } catch (err) {
+            const errRes = await options.errorHandler(err);
+            if (!errRes) {
+              return;
+            }
+            res = errRes;
+          }
+        } else {
+          res = await res.catch(handleFetchError);
+        }
+      }
+      if (cacheKey in res) {
+        return responseViaCache(res, outgoing);
+      }
+      const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+      if (res.body) {
+        const reader = res.body.getReader();
+        const values = [];
+        let done = false;
+        let currentReadPromise = void 0;
+        if (resHeaderRecord["transfer-encoding"] !== "chunked") {
+          let maxReadCount = 2;
+          for (let i = 0; i < maxReadCount; i++) {
+            currentReadPromise ||= reader.read();
+            const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+              console.error(e);
+              done = true;
             });
+            if (!chunk) {
+              if (i === 1) {
+                await new Promise((resolve) => setTimeout(resolve));
+                maxReadCount = 3;
+                continue;
+              }
+              break;
+            }
+            currentReadPromise = void 0;
+            if (chunk.value) {
+              values.push(chunk.value);
+            }
+            if (chunk.done) {
+              done = true;
+              break;
+            }
+          }
+          if (done && !("content-length" in resHeaderRecord)) {
+            resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+          }
+        }
+        outgoing.writeHead(res.status, resHeaderRecord);
+        values.forEach((value) => {
+          ;
+          outgoing.write(value);
+        });
+        if (done) {
+          outgoing.end();
+        } else {
+          if (values.length === 0) {
+            flushHeaders(outgoing);
+          }
+          await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
         }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    return server;
-}
-function parseArgs() {
-    const args = process.argv.slice(2);
-    let transport = "http"; // Default transport
-    let port = 3000;
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === "--transport" || arg === "-t") {
-            const value = args[i + 1];
-            if (value && !value.startsWith("-")) {
-                transport = value.toLowerCase();
-                i++;
-            }
-        }
-        else if (arg === "--port" || arg === "-p") {
-            const value = args[i + 1];
-            if (value && !value.startsWith("-")) {
-                const parsed = Number.parseInt(value, 10);
-                if (Number.isFinite(parsed)) {
-                    port = parsed;
+      } else if (resHeaderRecord[X_ALREADY_SENT]) {
+      } else {
+        outgoing.writeHead(res.status, resHeaderRecord);
+        outgoing.end();
+      }
+      ;
+      outgoing[outgoingEnded]?.();
+    };
+    getRequestListener = (fetchCallback, options = {}) => {
+      const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
+      if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
+        Object.defineProperty(global, "Request", {
+          value: Request2
+        });
+        Object.defineProperty(global, "Response", {
+          value: Response2
+        });
+      }
+      return async (incoming, outgoing) => {
+        let res, req;
+        try {
+          req = newRequest(incoming, options.hostname);
+          let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+          if (!incomingEnded) {
+            ;
+            incoming[wrapBodyStream] = true;
+            incoming.on("end", () => {
+              incomingEnded = true;
+            });
+            if (incoming instanceof Http2ServerRequest2) {
+              ;
+              outgoing[outgoingEnded] = () => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    if (!incomingEnded) {
+                      setTimeout(() => {
+                        incoming.destroy();
+                        outgoing.destroy();
+                      });
+                    }
+                  });
+                }
+              };
+            }
+          }
+          outgoing.on("close", () => {
+            const abortController = req[abortControllerKey];
+            if (abortController) {
+              if (incoming.errored) {
+                req[abortControllerKey].abort(incoming.errored.toString());
+              } else if (!outgoing.writableFinished) {
+                req[abortControllerKey].abort("Client connection prematurely closed.");
+              }
+            }
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                  });
                 }
-                i++;
+              });
+            }
+          });
+          res = fetchCallback(req, { incoming, outgoing });
+          if (cacheKey in res) {
+            return responseViaCache(res, outgoing);
+          }
+        } catch (e) {
+          if (!res) {
+            if (options.errorHandler) {
+              res = await options.errorHandler(req ? e : toRequestError(e));
+              if (!res) {
+                return;
+              }
+            } else if (!req) {
+              res = handleRequestError();
+            } else {
+              res = handleFetchError(e);
             }
+          } else {
+            return handleResponseError(e, outgoing);
+          }
+        }
+        try {
+          return await responseViaResponseObject(res, outgoing, options);
+        } catch (e) {
+          return handleResponseError(e, outgoing);
+        }
+      };
+    };
+    createAdaptorServer = (options) => {
+      const fetchCallback = options.fetch;
+      const requestListener = getRequestListener(fetchCallback, {
+        hostname: options.hostname,
+        overrideGlobalObjects: options.overrideGlobalObjects,
+        autoCleanupIncoming: options.autoCleanupIncoming
+      });
+      const createServer2 = options.createServer || createServerHTTP;
+      const server2 = createServer2(options.serverOptions || {}, requestListener);
+      return server2;
+    };
+    serve = (options, listeningListener) => {
+      const server2 = createAdaptorServer(options);
+      server2.listen(options?.port ?? 3e3, options.hostname, () => {
+        const serverInfo = server2.address();
+        listeningListener && listeningListener(serverInfo);
+      });
+      return server2;
+    };
+  }
+});
+
+// ../../packages/mcp-core/dist/config-schema.js
+function parseCliFromDefs(defs, argv) {
+  const config2 = {};
+  const flagMap = /* @__PURE__ */ new Map();
+  const negationMap = /* @__PURE__ */ new Map();
+  for (const [key, def] of Object.entries(defs)) {
+    flagMap.set(def.cli, { key, def });
+    if (def.type === "boolean") {
+      const baseName = def.cli.replace(/^--/, "");
+      negationMap.set(`--no-${baseName}`, key);
+    }
+  }
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const nextArg = argv[i + 1];
+    const negKey = negationMap.get(arg);
+    if (negKey !== void 0) {
+      config2[negKey] = false;
+      continue;
+    }
+    const entry = flagMap.get(arg);
+    if (!entry)
+      continue;
+    const { key, def } = entry;
+    switch (def.type) {
+      case "boolean":
+        config2[key] = true;
+        break;
+      case "string":
+        if (nextArg && !nextArg.startsWith("-")) {
+          config2[key] = nextArg;
+          i++;
+        }
+        break;
+      case "number":
+        if (nextArg && !nextArg.startsWith("-")) {
+          const num = Number(nextArg);
+          if (Number.isFinite(num)) {
+            config2[key] = num;
+          }
+          i++;
+        }
+        break;
+      case "string[]":
+        if (nextArg && !nextArg.startsWith("-")) {
+          config2[key] = nextArg.split(",").map((s) => s.trim());
+          i++;
+        }
+        break;
+    }
+  }
+  return config2;
+}
+function parseEnvFromDefs(defs, env) {
+  const config2 = {};
+  for (const [key, def] of Object.entries(defs)) {
+    if (!def.env)
+      continue;
+    const val = env[def.env];
+    if (val === void 0)
+      continue;
+    switch (def.type) {
+      case "boolean":
+        if (val === "true")
+          config2[key] = true;
+        else if (val === "false")
+          config2[key] = false;
+        break;
+      case "number": {
+        if (val === "")
+          break;
+        const num = Number(val);
+        if (Number.isFinite(num))
+          config2[key] = num;
+        break;
+      }
+      case "string":
+        if (val)
+          config2[key] = val;
+        break;
+      case "string[]":
+        if (val)
+          config2[key] = val.split(",").map((s) => s.trim());
+        break;
+    }
+  }
+  return config2;
+}
+function getDefaultsFromDefs(defs) {
+  const defaults = {};
+  for (const [key, def] of Object.entries(defs)) {
+    if (def.default !== void 0) {
+      defaults[key] = def.default;
+    }
+  }
+  return defaults;
+}
+function generateHelp(defs, opts) {
+  const lines = [];
+  if (opts?.usage) {
+    lines.push(`Usage: ${opts.usage}`);
+    lines.push("");
+  }
+  lines.push("Options:");
+  lines.push("  --help, -h                  Show this help message");
+  lines.push("  --version, -v               Show version number");
+  lines.push("  --init                      Generate .voicevoxrc.json with default settings");
+  lines.push("");
+  const groups = /* @__PURE__ */ new Map();
+  for (const [key, def] of Object.entries(defs)) {
+    const group = def.group;
+    if (!groups.has(group))
+      groups.set(group, []);
+    groups.get(group).push({ key, def });
+  }
+  for (const [groupName, entries] of groups) {
+    lines.push(`  ${groupName}:`);
+    for (const { def } of entries) {
+      const flag = def.type === "boolean" ? def.cli : `${def.cli} ${def.valueName || "<value>"}`;
+      const defaultStr = def.default !== void 0 ? ` (default: ${Array.isArray(def.default) ? def.default.join(",") : def.default})` : "";
+      const line = `  ${flag.padEnd(28)}${def.description}${defaultStr}`;
+      lines.push(line);
+      if (def.type === "boolean") {
+        const baseName = def.cli.replace(/^--/, "");
+        const negFlag = `--no-${baseName}`;
+        lines.push(`  ${negFlag.padEnd(28)}Disable ${def.description.toLowerCase().replace(/^enable /, "")}`);
+      }
+    }
+    lines.push("");
+  }
+  if (opts?.examples?.length) {
+    lines.push("Examples:");
+    for (const ex of opts.examples) {
+      lines.push(`  ${ex}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function filterUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([_, v]) => v !== void 0));
+}
+
+// ../../packages/mcp-core/dist/config.js
+var baseConfigDefs = {
+  httpMode: {
+    cli: "--http",
+    env: "MCP_HTTP_MODE",
+    description: "Enable HTTP server mode",
+    group: "Server Options",
+    type: "boolean",
+    default: false
+  },
+  httpPort: {
+    cli: "--port",
+    env: "MCP_HTTP_PORT",
+    description: "HTTP server port",
+    group: "Server Options",
+    type: "number",
+    default: 3e3,
+    valueName: "<port>"
+  },
+  httpHost: {
+    cli: "--host",
+    env: "MCP_HTTP_HOST",
+    description: "HTTP server host",
+    group: "Server Options",
+    type: "string",
+    default: "0.0.0.0",
+    valueName: "<host>"
+  },
+  allowedHosts: {
+    cli: "--allowed-hosts",
+    env: "MCP_ALLOWED_HOSTS",
+    description: "Comma-separated list of allowed hosts",
+    group: "Server Options",
+    type: "string[]",
+    default: ["localhost", "127.0.0.1", "[::1]"],
+    valueName: "<hosts>"
+  },
+  allowedOrigins: {
+    cli: "--allowed-origins",
+    env: "MCP_ALLOWED_ORIGINS",
+    description: "Comma-separated list of allowed origins",
+    group: "Server Options",
+    type: "string[]",
+    default: [
+      "http://localhost",
+      "http://127.0.0.1",
+      "https://localhost",
+      "https://127.0.0.1"
+    ],
+    valueName: "<origins>"
+  },
+  apiKey: {
+    cli: "--api-key",
+    env: "MCP_API_KEY",
+    description: "Require matching API key via X-API-Key or Authorization: Bearer",
+    group: "Server Options",
+    type: "string",
+    valueName: "<key>"
+  }
+};
+var defaultBaseConfig = getDefaultsFromDefs(baseConfigDefs);
+
+// ../../packages/mcp-core/dist/session.js
+var sessionConfigs = /* @__PURE__ */ new Map();
+function deleteSessionConfig(sessionId) {
+  sessionConfigs.delete(sessionId);
+}
+
+// ../../packages/mcp-core/dist/http.js
+import { randomUUID } from "crypto";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/compose.js
+var compose = (middleware, onError, onNotFound) => {
+  return (context, next) => {
+    let index = -1;
+    return dispatch(0);
+    async function dispatch(i) {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      let res;
+      let isError = false;
+      let handler;
+      if (middleware[i]) {
+        handler = middleware[i][0][0];
+        context.req.routeIndex = i;
+      } else {
+        handler = i === middleware.length && next || void 0;
+      }
+      if (handler) {
+        try {
+          res = await handler(context, () => dispatch(i + 1));
+        } catch (err) {
+          if (err instanceof Error && onError) {
+            context.error = err;
+            res = await onError(err, context);
+            isError = true;
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        if (context.finalized === false && onNotFound) {
+          res = await onNotFound(context);
+        }
+      }
+      if (res && (context.finalized === false || isError)) {
+        context.res = res;
+      }
+      return context;
+    }
+  };
+};
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/request/constants.js
+var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/utils/body.js
+var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+  const { all = false, dot = false } = options;
+  const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
+  const contentType = headers.get("Content-Type");
+  if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) {
+    return parseFormData(request, { all, dot });
+  }
+  return {};
+};
+async function parseFormData(request, options) {
+  const formData = await request.formData();
+  if (formData) {
+    return convertFormDataToBodyData(formData, options);
+  }
+  return {};
+}
+function convertFormDataToBodyData(formData, options) {
+  const form = /* @__PURE__ */ Object.create(null);
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith("[]");
+    if (!shouldParseAllValues) {
+      form[key] = value;
+    } else {
+      handleParsingAllValues(form, key, value);
+    }
+  });
+  if (options.dot) {
+    Object.entries(form).forEach(([key, value]) => {
+      const shouldParseDotValues = key.includes(".");
+      if (shouldParseDotValues) {
+        handleParsingNestedValues(form, key, value);
+        delete form[key];
+      }
+    });
+  }
+  return form;
+}
+var handleParsingAllValues = (form, key, value) => {
+  if (form[key] !== void 0) {
+    if (Array.isArray(form[key])) {
+      ;
+      form[key].push(value);
+    } else {
+      form[key] = [form[key], value];
+    }
+  } else {
+    if (!key.endsWith("[]")) {
+      form[key] = value;
+    } else {
+      form[key] = [value];
+    }
+  }
+};
+var handleParsingNestedValues = (form, key, value) => {
+  let nestedForm = form;
+  const keys = key.split(".");
+  keys.forEach((key2, index) => {
+    if (index === keys.length - 1) {
+      nestedForm[key2] = value;
+    } else {
+      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+      }
+      nestedForm = nestedForm[key2];
+    }
+  });
+};
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/utils/url.js
+var splitPath = (path) => {
+  const paths = path.split("/");
+  if (paths[0] === "") {
+    paths.shift();
+  }
+  return paths;
+};
+var splitRoutingPath = (routePath) => {
+  const { groups, path } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path);
+  return replaceGroupMarks(paths, groups);
+};
+var extractGroupsFromPath = (path) => {
+  const groups = [];
+  path = path.replace(/\{[^}]+\}/g, (match2, index) => {
+    const mark = `@${index}`;
+    groups.push([mark, match2]);
+    return mark;
+  });
+  return { groups, path };
+};
+var replaceGroupMarks = (paths, groups) => {
+  for (let i = groups.length - 1; i >= 0; i--) {
+    const [mark] = groups[i];
+    for (let j = paths.length - 1; j >= 0; j--) {
+      if (paths[j].includes(mark)) {
+        paths[j] = paths[j].replace(mark, groups[i][1]);
+        break;
+      }
+    }
+  }
+  return paths;
+};
+var patternCache = {};
+var getPattern = (label, next) => {
+  if (label === "*") {
+    return "*";
+  }
+  const match2 = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match2) {
+    const cacheKey2 = `${label}#${next}`;
+    if (!patternCache[cacheKey2]) {
+      if (match2[2]) {
+        patternCache[cacheKey2] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey2, match2[1], new RegExp(`^${match2[2]}(?=/${next})`)] : [label, match2[1], new RegExp(`^${match2[2]}$`)];
+      } else {
+        patternCache[cacheKey2] = [label, match2[1], true];
+      }
+    }
+    return patternCache[cacheKey2];
+  }
+  return null;
+};
+var tryDecode = (str, decoder) => {
+  try {
+    return decoder(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match2) => {
+      try {
+        return decoder(match2);
+      } catch {
+        return match2;
+      }
+    });
+  }
+};
+var tryDecodeURI = (str) => tryDecode(str, decodeURI);
+var getPath = (request) => {
+  const url = request.url;
+  const start = url.indexOf("/", url.indexOf(":") + 4);
+  let i = start;
+  for (; i < url.length; i++) {
+    const charCode = url.charCodeAt(i);
+    if (charCode === 37) {
+      const queryIndex = url.indexOf("?", i);
+      const path = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
+      return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
+    } else if (charCode === 63) {
+      break;
+    }
+  }
+  return url.slice(start, i);
+};
+var getPathNoStrict = (request) => {
+  const result = getPath(request);
+  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
+};
+var mergePath = (base, sub, ...rest) => {
+  if (rest.length) {
+    sub = mergePath(sub, ...rest);
+  }
+  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
+};
+var checkOptionalParameter = (path) => {
+  if (path.charCodeAt(path.length - 1) !== 63 || !path.includes(":")) {
+    return null;
+  }
+  const segments = path.split("/");
+  const results = [];
+  let basePath = "";
+  segments.forEach((segment) => {
+    if (segment !== "" && !/\:/.test(segment)) {
+      basePath += "/" + segment;
+    } else if (/\:/.test(segment)) {
+      if (/\?/.test(segment)) {
+        if (results.length === 0 && basePath === "") {
+          results.push("/");
+        } else {
+          results.push(basePath);
+        }
+        const optionalSegment = segment.replace("?", "");
+        basePath += "/" + optionalSegment;
+        results.push(basePath);
+      } else {
+        basePath += "/" + segment;
+      }
+    }
+  });
+  return results.filter((v, i, a) => a.indexOf(v) === i);
+};
+var _decodeURI = (value) => {
+  if (!/[%+]/.test(value)) {
+    return value;
+  }
+  if (value.indexOf("+") !== -1) {
+    value = value.replace(/\+/g, " ");
+  }
+  return value.indexOf("%") !== -1 ? tryDecode(value, decodeURIComponent_) : value;
+};
+var _getQueryParam = (url, key, multiple) => {
+  let encoded;
+  if (!multiple && key && !/[%+]/.test(key)) {
+    let keyIndex2 = url.indexOf("?", 8);
+    if (keyIndex2 === -1) {
+      return void 0;
+    }
+    if (!url.startsWith(key, keyIndex2 + 1)) {
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    while (keyIndex2 !== -1) {
+      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+      if (trailingKeyCode === 61) {
+        const valueIndex = keyIndex2 + key.length + 2;
+        const endIndex = url.indexOf("&", valueIndex);
+        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
+      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
+        return "";
+      }
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    encoded = /[%+]/.test(url);
+    if (!encoded) {
+      return void 0;
+    }
+  }
+  const results = {};
+  encoded ??= /[%+]/.test(url);
+  let keyIndex = url.indexOf("?", 8);
+  while (keyIndex !== -1) {
+    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+    let valueIndex = url.indexOf("=", keyIndex);
+    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
+      valueIndex = -1;
+    }
+    let name = url.slice(
+      keyIndex + 1,
+      valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex
+    );
+    if (encoded) {
+      name = _decodeURI(name);
+    }
+    keyIndex = nextKeyIndex;
+    if (name === "") {
+      continue;
+    }
+    let value;
+    if (valueIndex === -1) {
+      value = "";
+    } else {
+      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
+      if (encoded) {
+        value = _decodeURI(value);
+      }
+    }
+    if (multiple) {
+      if (!(results[name] && Array.isArray(results[name]))) {
+        results[name] = [];
+      }
+      ;
+      results[name].push(value);
+    } else {
+      results[name] ??= value;
+    }
+  }
+  return key ? results[key] : results;
+};
+var getQueryParam = _getQueryParam;
+var getQueryParams = (url, key) => {
+  return _getQueryParam(url, key, true);
+};
+var decodeURIComponent_ = decodeURIComponent;
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/request.js
+var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
+var HonoRequest = class {
+  /**
+   * `.raw` can get the raw Request object.
+   *
+   * @see {@link https://hono.dev/docs/api/request#raw}
+   *
+   * @example
+   * ```ts
+   * // For Cloudflare Workers
+   * app.post('/', async (c) => {
+   *   const metadata = c.req.raw.cf?.hostMetadata?
+   *   ...
+   * })
+   * ```
+   */
+  raw;
+  #validatedData;
+  // Short name of validatedData
+  #matchResult;
+  routeIndex = 0;
+  /**
+   * `.path` can get the pathname of the request.
+   *
+   * @see {@link https://hono.dev/docs/api/request#path}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const pathname = c.req.path // `/about/me`
+   * })
+   * ```
+   */
+  path;
+  bodyCache = {};
+  constructor(request, path = "/", matchResult = [[]]) {
+    this.raw = request;
+    this.path = path;
+    this.#matchResult = matchResult;
+    this.#validatedData = {};
+  }
+  param(key) {
+    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+  }
+  #getDecodedParam(key) {
+    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
+    const param = this.#getParamValue(paramKey);
+    return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
+  }
+  #getAllDecodedParams() {
+    const decoded = {};
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
+    for (const key of keys) {
+      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+      if (value !== void 0) {
+        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
+      }
+    }
+    return decoded;
+  }
+  #getParamValue(paramKey) {
+    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+  }
+  query(key) {
+    return getQueryParam(this.url, key);
+  }
+  queries(key) {
+    return getQueryParams(this.url, key);
+  }
+  header(name) {
+    if (name) {
+      return this.raw.headers.get(name) ?? void 0;
+    }
+    const headerData = {};
+    this.raw.headers.forEach((value, key) => {
+      headerData[key] = value;
+    });
+    return headerData;
+  }
+  async parseBody(options) {
+    return this.bodyCache.parsedBody ??= await parseBody(this, options);
+  }
+  #cachedBody = (key) => {
+    const { bodyCache, raw: raw2 } = this;
+    const cachedBody = bodyCache[key];
+    if (cachedBody) {
+      return cachedBody;
+    }
+    const anyCachedKey = Object.keys(bodyCache)[0];
+    if (anyCachedKey) {
+      return bodyCache[anyCachedKey].then((body) => {
+        if (anyCachedKey === "json") {
+          body = JSON.stringify(body);
+        }
+        return new Response(body)[key]();
+      });
+    }
+    return bodyCache[key] = raw2[key]();
+  };
+  /**
+   * `.json()` can parse Request body of type `application/json`
+   *
+   * @see {@link https://hono.dev/docs/api/request#json}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.json()
+   * })
+   * ```
+   */
+  json() {
+    return this.#cachedBody("text").then((text) => JSON.parse(text));
+  }
+  /**
+   * `.text()` can parse Request body of type `text/plain`
+   *
+   * @see {@link https://hono.dev/docs/api/request#text}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.text()
+   * })
+   * ```
+   */
+  text() {
+    return this.#cachedBody("text");
+  }
+  /**
+   * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+   *
+   * @see {@link https://hono.dev/docs/api/request#arraybuffer}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.arrayBuffer()
+   * })
+   * ```
+   */
+  arrayBuffer() {
+    return this.#cachedBody("arrayBuffer");
+  }
+  /**
+   * Parses the request body as a `Blob`.
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.blob();
+   * });
+   * ```
+   * @see https://hono.dev/docs/api/request#blob
+   */
+  blob() {
+    return this.#cachedBody("blob");
+  }
+  /**
+   * Parses the request body as `FormData`.
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.formData();
+   * });
+   * ```
+   * @see https://hono.dev/docs/api/request#formdata
+   */
+  formData() {
+    return this.#cachedBody("formData");
+  }
+  /**
+   * Adds validated data to the request.
+   *
+   * @param target - The target of the validation.
+   * @param data - The validated data to add.
+   */
+  addValidatedData(target, data) {
+    this.#validatedData[target] = data;
+  }
+  valid(target) {
+    return this.#validatedData[target];
+  }
+  /**
+   * `.url()` can get the request url strings.
+   *
+   * @see {@link https://hono.dev/docs/api/request#url}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const url = c.req.url // `http://localhost:8787/about/me`
+   *   ...
+   * })
+   * ```
+   */
+  get url() {
+    return this.raw.url;
+  }
+  /**
+   * `.method()` can get the method name of the request.
+   *
+   * @see {@link https://hono.dev/docs/api/request#method}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const method = c.req.method // `GET`
+   * })
+   * ```
+   */
+  get method() {
+    return this.raw.method;
+  }
+  get [GET_MATCH_RESULT]() {
+    return this.#matchResult;
+  }
+  /**
+   * `.matchedRoutes()` can return a matched route in the handler
+   *
+   * @deprecated
+   *
+   * Use matchedRoutes helper defined in "hono/route" instead.
+   *
+   * @see {@link https://hono.dev/docs/api/request#matchedroutes}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async function logger(c, next) {
+   *   await next()
+   *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+   *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+   *     console.log(
+   *       method,
+   *       ' ',
+   *       path,
+   *       ' '.repeat(Math.max(10 - path.length, 0)),
+   *       name,
+   *       i === c.req.routeIndex ? '<- respond from here' : ''
+   *     )
+   *   })
+   * })
+   * ```
+   */
+  get matchedRoutes() {
+    return this.#matchResult[0].map(([[, route]]) => route);
+  }
+  /**
+   * `routePath()` can retrieve the path registered within the handler
+   *
+   * @deprecated
+   *
+   * Use routePath helper defined in "hono/route" instead.
+   *
+   * @see {@link https://hono.dev/docs/api/request#routepath}
+   *
+   * @example
+   * ```ts
+   * app.get('/posts/:id', (c) => {
+   *   return c.json({ path: c.req.routePath })
+   * })
+   * ```
+   */
+  get routePath() {
+    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/utils/html.js
+var HtmlEscapedCallbackPhase = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3
+};
+var raw = (value, callbacks) => {
+  const escapedString = new String(value);
+  escapedString.isEscaped = true;
+  escapedString.callbacks = callbacks;
+  return escapedString;
+};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str === "object" && !(str instanceof String)) {
+    if (!(str instanceof Promise)) {
+      str = str.toString();
+    }
+    if (str instanceof Promise) {
+      str = await str;
+    }
+  }
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return Promise.resolve(str);
+  }
+  if (buffer) {
+    buffer[0] += str;
+  } else {
+    buffer = [str];
+  }
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
+    (res) => Promise.all(
+      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
+    ).then(() => buffer[0])
+  );
+  if (preserveCallbacks) {
+    return raw(await resStr, callbacks);
+  } else {
+    return resStr;
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/context.js
+var TEXT_PLAIN = "text/plain; charset=UTF-8";
+var setDefaultContentType = (contentType, headers) => {
+  return {
+    "Content-Type": contentType,
+    ...headers
+  };
+};
+var Context = class {
+  #rawRequest;
+  #req;
+  /**
+   * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
+   *
+   * @see {@link https://hono.dev/docs/api/context#env}
+   *
+   * @example
+   * ```ts
+   * // Environment object for Cloudflare Workers
+   * app.get('*', async c => {
+   *   const counter = c.env.COUNTER
+   * })
+   * ```
+   */
+  env = {};
+  #var;
+  finalized = false;
+  /**
+   * `.error` can get the error object from the middleware if the Handler throws an error.
+   *
+   * @see {@link https://hono.dev/docs/api/context#error}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async (c, next) => {
+   *   await next()
+   *   if (c.error) {
+   *     // do something...
+   *   }
+   * })
+   * ```
+   */
+  error;
+  #status;
+  #executionCtx;
+  #res;
+  #layout;
+  #renderer;
+  #notFoundHandler;
+  #preparedHeaders;
+  #matchResult;
+  #path;
+  /**
+   * Creates an instance of the Context class.
+   *
+   * @param req - The Request object.
+   * @param options - Optional configuration options for the context.
+   */
+  constructor(req, options) {
+    this.#rawRequest = req;
+    if (options) {
+      this.#executionCtx = options.executionCtx;
+      this.env = options.env;
+      this.#notFoundHandler = options.notFoundHandler;
+      this.#path = options.path;
+      this.#matchResult = options.matchResult;
+    }
+  }
+  /**
+   * `.req` is the instance of {@link HonoRequest}.
+   */
+  get req() {
+    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+    return this.#req;
+  }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#event}
+   * The FetchEvent associated with the current request.
+   *
+   * @throws Will throw an error if the context does not have a FetchEvent.
+   */
+  get event() {
+    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no FetchEvent");
+    }
+  }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#executionctx}
+   * The ExecutionContext associated with the current request.
+   *
+   * @throws Will throw an error if the context does not have an ExecutionContext.
+   */
+  get executionCtx() {
+    if (this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no ExecutionContext");
+    }
+  }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#res}
+   * The Response object for the current request.
+   */
+  get res() {
+    return this.#res ||= new Response(null, {
+      headers: this.#preparedHeaders ??= new Headers()
+    });
+  }
+  /**
+   * Sets the Response object for the current request.
+   *
+   * @param _res - The Response object to set.
+   */
+  set res(_res) {
+    if (this.#res && _res) {
+      _res = new Response(_res.body, _res);
+      for (const [k, v] of this.#res.headers.entries()) {
+        if (k === "content-type") {
+          continue;
+        }
+        if (k === "set-cookie") {
+          const cookies = this.#res.headers.getSetCookie();
+          _res.headers.delete("set-cookie");
+          for (const cookie of cookies) {
+            _res.headers.append("set-cookie", cookie);
+          }
+        } else {
+          _res.headers.set(k, v);
+        }
+      }
+    }
+    this.#res = _res;
+    this.finalized = true;
+  }
+  /**
+   * `.render()` can create a response within a layout.
+   *
+   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+   *
+   * @example
+   * ```ts
+   * app.get('/', (c) => {
+   *   return c.render('Hello!')
+   * })
+   * ```
+   */
+  render = (...args) => {
+    this.#renderer ??= (content) => this.html(content);
+    return this.#renderer(...args);
+  };
+  /**
+   * Sets the layout for the response.
+   *
+   * @param layout - The layout to set.
+   * @returns The layout function.
+   */
+  setLayout = (layout) => this.#layout = layout;
+  /**
+   * Gets the current layout for the response.
+   *
+   * @returns The current layout function.
+   */
+  getLayout = () => this.#layout;
+  /**
+   * `.setRenderer()` can set the layout in the custom middleware.
+   *
+   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+   *
+   * @example
+   * ```tsx
+   * app.use('*', async (c, next) => {
+   *   c.setRenderer((content) => {
+   *     return c.html(
+   *       <html>
+   *         <body>
+   *           <p>{content}</p>
+   *         </body>
+   *       </html>
+   *     )
+   *   })
+   *   await next()
+   * })
+   * ```
+   */
+  setRenderer = (renderer) => {
+    this.#renderer = renderer;
+  };
+  /**
+   * `.header()` can set headers.
+   *
+   * @see {@link https://hono.dev/docs/api/context#header}
+   *
+   * @example
+   * ```ts
+   * app.get('/welcome', (c) => {
+   *   // Set headers
+   *   c.header('X-Message', 'Hello!')
+   *   c.header('Content-Type', 'text/plain')
+   *
+   *   return c.body('Thank you for coming')
+   * })
+   * ```
+   */
+  header = (name, value, options) => {
+    if (this.finalized) {
+      this.#res = new Response(this.#res.body, this.#res);
+    }
+    const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers();
+    if (value === void 0) {
+      headers.delete(name);
+    } else if (options?.append) {
+      headers.append(name, value);
+    } else {
+      headers.set(name, value);
+    }
+  };
+  status = (status) => {
+    this.#status = status;
+  };
+  /**
+   * `.set()` can set the value specified by the key.
+   *
+   * @see {@link https://hono.dev/docs/api/context#set-get}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async (c, next) => {
+   *   c.set('message', 'Hono is hot!!')
+   *   await next()
+   * })
+   * ```
+   */
+  set = (key, value) => {
+    this.#var ??= /* @__PURE__ */ new Map();
+    this.#var.set(key, value);
+  };
+  /**
+   * `.get()` can use the value specified by the key.
+   *
+   * @see {@link https://hono.dev/docs/api/context#set-get}
+   *
+   * @example
+   * ```ts
+   * app.get('/', (c) => {
+   *   const message = c.get('message')
+   *   return c.text(`The message is "${message}"`)
+   * })
+   * ```
+   */
+  get = (key) => {
+    return this.#var ? this.#var.get(key) : void 0;
+  };
+  /**
+   * `.var` can access the value of a variable.
+   *
+   * @see {@link https://hono.dev/docs/api/context#var}
+   *
+   * @example
+   * ```ts
+   * const result = c.var.client.oneMethod()
+   * ```
+   */
+  // c.var.propName is a read-only
+  get var() {
+    if (!this.#var) {
+      return {};
+    }
+    return Object.fromEntries(this.#var);
+  }
+  #newResponse(data, arg, headers) {
+    const responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders ?? new Headers();
+    if (typeof arg === "object" && "headers" in arg) {
+      const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers);
+      for (const [key, value] of argHeaders) {
+        if (key.toLowerCase() === "set-cookie") {
+          responseHeaders.append(key, value);
+        } else {
+          responseHeaders.set(key, value);
+        }
+      }
+    }
+    if (headers) {
+      for (const [k, v] of Object.entries(headers)) {
+        if (typeof v === "string") {
+          responseHeaders.set(k, v);
+        } else {
+          responseHeaders.delete(k);
+          for (const v2 of v) {
+            responseHeaders.append(k, v2);
+          }
+        }
+      }
+    }
+    const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
+    return new Response(data, { status, headers: responseHeaders });
+  }
+  newResponse = (...args) => this.#newResponse(...args);
+  /**
+   * `.body()` can return the HTTP response.
+   * You can set headers with `.header()` and set HTTP status code with `.status`.
+   * This can also be set in `.text()`, `.json()` and so on.
+   *
+   * @see {@link https://hono.dev/docs/api/context#body}
+   *
+   * @example
+   * ```ts
+   * app.get('/welcome', (c) => {
+   *   // Set headers
+   *   c.header('X-Message', 'Hello!')
+   *   c.header('Content-Type', 'text/plain')
+   *   // Set HTTP status code
+   *   c.status(201)
+   *
+   *   // Return the response body
+   *   return c.body('Thank you for coming')
+   * })
+   * ```
+   */
+  body = (data, arg, headers) => this.#newResponse(data, arg, headers);
+  /**
+   * `.text()` can render text as `Content-Type:text/plain`.
+   *
+   * @see {@link https://hono.dev/docs/api/context#text}
+   *
+   * @example
+   * ```ts
+   * app.get('/say', (c) => {
+   *   return c.text('Hello!')
+   * })
+   * ```
+   */
+  text = (text, arg, headers) => {
+    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(
+      text,
+      arg,
+      setDefaultContentType(TEXT_PLAIN, headers)
+    );
+  };
+  /**
+   * `.json()` can render JSON as `Content-Type:application/json`.
+   *
+   * @see {@link https://hono.dev/docs/api/context#json}
+   *
+   * @example
+   * ```ts
+   * app.get('/api', (c) => {
+   *   return c.json({ message: 'Hello!' })
+   * })
+   * ```
+   */
+  json = (object, arg, headers) => {
+    return this.#newResponse(
+      JSON.stringify(object),
+      arg,
+      setDefaultContentType("application/json", headers)
+    );
+  };
+  html = (html, arg, headers) => {
+    const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
+    return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
+  };
+  /**
+   * `.redirect()` can Redirect, default status code is 302.
+   *
+   * @see {@link https://hono.dev/docs/api/context#redirect}
+   *
+   * @example
+   * ```ts
+   * app.get('/redirect', (c) => {
+   *   return c.redirect('/')
+   * })
+   * app.get('/redirect-permanently', (c) => {
+   *   return c.redirect('/', 301)
+   * })
+   * ```
+   */
+  redirect = (location, status) => {
+    const locationString = String(location);
+    this.header(
+      "Location",
+      // Multibyes should be encoded
+      // eslint-disable-next-line no-control-regex
+      !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString)
+    );
+    return this.newResponse(null, status ?? 302);
+  };
+  /**
+   * `.notFound()` can return the Not Found Response.
+   *
+   * @see {@link https://hono.dev/docs/api/context#notfound}
+   *
+   * @example
+   * ```ts
+   * app.get('/notfound', (c) => {
+   *   return c.notFound()
+   * })
+   * ```
+   */
+  notFound = () => {
+    this.#notFoundHandler ??= () => new Response();
+    return this.#notFoundHandler(this);
+  };
+};
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/router.js
+var METHOD_NAME_ALL = "ALL";
+var METHOD_NAME_ALL_LOWERCASE = "all";
+var METHODS = ["get", "post", "put", "delete", "options", "patch"];
+var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+var UnsupportedPathError = class extends Error {
+};
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/utils/constants.js
+var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/hono-base.js
+var notFoundHandler = (c) => {
+  return c.text("404 Not Found", 404);
+};
+var errorHandler = (err, c) => {
+  if ("getResponse" in err) {
+    const res = err.getResponse();
+    return c.newResponse(res.body, res);
+  }
+  console.error(err);
+  return c.text("Internal Server Error", 500);
+};
+var Hono = class _Hono {
+  get;
+  post;
+  put;
+  delete;
+  options;
+  patch;
+  all;
+  on;
+  use;
+  /*
+    This class is like an abstract class and does not have a router.
+    To use it, inherit the class and implement router in the constructor.
+  */
+  router;
+  getPath;
+  // Cannot use `#` because it requires visibility at JavaScript runtime.
+  _basePath = "/";
+  #path = "/";
+  routes = [];
+  constructor(options = {}) {
+    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
+    allMethods.forEach((method) => {
+      this[method] = (args1, ...args) => {
+        if (typeof args1 === "string") {
+          this.#path = args1;
+        } else {
+          this.#addRoute(method, this.#path, args1);
+        }
+        args.forEach((handler) => {
+          this.#addRoute(method, this.#path, handler);
+        });
+        return this;
+      };
+    });
+    this.on = (method, path, ...handlers) => {
+      for (const p of [path].flat()) {
+        this.#path = p;
+        for (const m of [method].flat()) {
+          handlers.map((handler) => {
+            this.#addRoute(m.toUpperCase(), this.#path, handler);
+          });
+        }
+      }
+      return this;
+    };
+    this.use = (arg1, ...handlers) => {
+      if (typeof arg1 === "string") {
+        this.#path = arg1;
+      } else {
+        this.#path = "*";
+        handlers.unshift(arg1);
+      }
+      handlers.forEach((handler) => {
+        this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
+      });
+      return this;
+    };
+    const { strict, ...optionsWithoutStrict } = options;
+    Object.assign(this, optionsWithoutStrict);
+    this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
+  }
+  #clone() {
+    const clone = new _Hono({
+      router: this.router,
+      getPath: this.getPath
+    });
+    clone.errorHandler = this.errorHandler;
+    clone.#notFoundHandler = this.#notFoundHandler;
+    clone.routes = this.routes;
+    return clone;
+  }
+  #notFoundHandler = notFoundHandler;
+  // Cannot use `#` because it requires visibility at JavaScript runtime.
+  errorHandler = errorHandler;
+  /**
+   * `.route()` allows grouping other Hono instance in routes.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#grouping}
+   *
+   * @param {string} path - base Path
+   * @param {Hono} app - other Hono instance
+   * @returns {Hono} routed Hono instance
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * const app2 = new Hono()
+   *
+   * app2.get("/user", (c) => c.text("user"))
+   * app.route("/api", app2) // GET /api/user
+   * ```
+   */
+  route(path, app) {
+    const subApp = this.basePath(path);
+    app.routes.map((r) => {
+      let handler;
+      if (app.errorHandler === errorHandler) {
+        handler = r.handler;
+      } else {
+        handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+        handler[COMPOSED_HANDLER] = r.handler;
+      }
+      subApp.#addRoute(r.method, r.path, handler);
+    });
+    return this;
+  }
+  /**
+   * `.basePath()` allows base paths to be specified.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#base-path}
+   *
+   * @param {string} path - base Path
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * const api = new Hono().basePath('/api')
+   * ```
+   */
+  basePath(path) {
+    const subApp = this.#clone();
+    subApp._basePath = mergePath(this._basePath, path);
+    return subApp;
+  }
+  /**
+   * `.onError()` handles an error and returns a customized Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#error-handling}
+   *
+   * @param {ErrorHandler} handler - request Handler for error
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.onError((err, c) => {
+   *   console.error(`${err}`)
+   *   return c.text('Custom Error Message', 500)
+   * })
+   * ```
+   */
+  onError = (handler) => {
+    this.errorHandler = handler;
+    return this;
+  };
+  /**
+   * `.notFound()` allows you to customize a Not Found Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#not-found}
+   *
+   * @param {NotFoundHandler} handler - request handler for not-found
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.notFound((c) => {
+   *   return c.text('Custom 404 Message', 404)
+   * })
+   * ```
+   */
+  notFound = (handler) => {
+    this.#notFoundHandler = handler;
+    return this;
+  };
+  /**
+   * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#mount}
+   *
+   * @param {string} path - base Path
+   * @param {Function} applicationHandler - other Request Handler
+   * @param {MountOptions} [options] - options of `.mount()`
+   * @returns {Hono} mounted Hono instance
+   *
+   * @example
+   * ```ts
+   * import { Router as IttyRouter } from 'itty-router'
+   * import { Hono } from 'hono'
+   * // Create itty-router application
+   * const ittyRouter = IttyRouter()
+   * // GET /itty-router/hello
+   * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+   *
+   * const app = new Hono()
+   * app.mount('/itty-router', ittyRouter.handle)
+   * ```
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * // Send the request to another application without modification.
+   * app.mount('/app', anotherApp, {
+   *   replaceRequest: (req) => req,
+   * })
+   * ```
+   */
+  mount(path, applicationHandler, options) {
+    let replaceRequest;
+    let optionHandler;
+    if (options) {
+      if (typeof options === "function") {
+        optionHandler = options;
+      } else {
+        optionHandler = options.optionHandler;
+        if (options.replaceRequest === false) {
+          replaceRequest = (request) => request;
+        } else {
+          replaceRequest = options.replaceRequest;
+        }
+      }
+    }
+    const getOptions = optionHandler ? (c) => {
+      const options2 = optionHandler(c);
+      return Array.isArray(options2) ? options2 : [options2];
+    } : (c) => {
+      let executionContext = void 0;
+      try {
+        executionContext = c.executionCtx;
+      } catch {
+      }
+      return [c.env, executionContext];
+    };
+    replaceRequest ||= (() => {
+      const mergedPath = mergePath(this._basePath, path);
+      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
+      return (request) => {
+        const url = new URL(request.url);
+        url.pathname = url.pathname.slice(pathPrefixLength) || "/";
+        return new Request(url, request);
+      };
+    })();
+    const handler = async (c, next) => {
+      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+      if (res) {
+        return res;
+      }
+      await next();
+    };
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
+    return this;
+  }
+  #addRoute(method, path, handler) {
+    method = method.toUpperCase();
+    path = mergePath(this._basePath, path);
+    const r = { basePath: this._basePath, path, method, handler };
+    this.router.add(method, path, [handler, r]);
+    this.routes.push(r);
+  }
+  #handleError(err, c) {
+    if (err instanceof Error) {
+      return this.errorHandler(err, c);
+    }
+    throw err;
+  }
+  #dispatch(request, executionCtx, env, method) {
+    if (method === "HEAD") {
+      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
+    }
+    const path = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path);
+    const c = new Context(request, {
+      path,
+      matchResult,
+      env,
+      executionCtx,
+      notFoundHandler: this.#notFoundHandler
+    });
+    if (matchResult[0].length === 1) {
+      let res;
+      try {
+        res = matchResult[0][0][0][0](c, async () => {
+          c.res = await this.#notFoundHandler(c);
+        });
+      } catch (err) {
+        return this.#handleError(err, c);
+      }
+      return res instanceof Promise ? res.then(
+        (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
+      ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
+    }
+    const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
+    return (async () => {
+      try {
+        const context = await composed(c);
+        if (!context.finalized) {
+          throw new Error(
+            "Context is not finalized. Did you forget to return a Response object or `await next()`?"
+          );
+        }
+        return context.res;
+      } catch (err) {
+        return this.#handleError(err, c);
+      }
+    })();
+  }
+  /**
+   * `.fetch()` will be entry point of your app.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#fetch}
+   *
+   * @param {Request} request - request Object of request
+   * @param {Env} Env - env Object
+   * @param {ExecutionContext} - context of execution
+   * @returns {Response | Promise<Response>} response of request
+   *
+   */
+  fetch = (request, ...rest) => {
+    return this.#dispatch(request, rest[1], rest[0], request.method);
+  };
+  /**
+   * `.request()` is a useful method for testing.
+   * You can pass a URL or pathname to send a GET request.
+   * app will return a Response object.
+   * ```ts
+   * test('GET /hello is ok', async () => {
+   *   const res = await app.request('/hello')
+   *   expect(res.status).toBe(200)
+   * })
+   * ```
+   * @see https://hono.dev/docs/api/hono#request
+   */
+  request = (input, requestInit, Env, executionCtx) => {
+    if (input instanceof Request) {
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+    }
+    input = input.toString();
+    return this.fetch(
+      new Request(
+        /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`,
+        requestInit
+      ),
+      Env,
+      executionCtx
+    );
+  };
+  /**
+   * `.fire()` automatically adds a global fetch event listener.
+   * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+   * @deprecated
+   * Use `fire` from `hono/service-worker` instead.
+   * ```ts
+   * import { Hono } from 'hono'
+   * import { fire } from 'hono/service-worker'
+   *
+   * const app = new Hono()
+   * // ...
+   * fire(app)
+   * ```
+   * @see https://hono.dev/docs/api/hono#fire
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+   * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+   */
+  fire = () => {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
+    });
+  };
+};
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/router/reg-exp-router/matcher.js
+var emptyParam = [];
+function match(method, path) {
+  const matchers = this.buildAllMatchers();
+  const match2 = ((method2, path2) => {
+    const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+    const staticMatch = matcher[2][path2];
+    if (staticMatch) {
+      return staticMatch;
+    }
+    const match3 = path2.match(matcher[0]);
+    if (!match3) {
+      return [[], emptyParam];
+    }
+    const index = match3.indexOf("", 1);
+    return [matcher[1][index], match3];
+  });
+  this.match = match2;
+  return match2(method, path);
+}
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/router/reg-exp-router/node.js
+var LABEL_REG_EXP_STR = "[^/]+";
+var ONLY_WILDCARD_REG_EXP_STR = ".*";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = /* @__PURE__ */ Symbol();
+var regExpMetaChars = new Set(".\\+*[^]$()");
+function compareKey(a, b) {
+  if (a.length === 1) {
+    return b.length === 1 ? a < b ? -1 : 1 : -1;
+  }
+  if (b.length === 1) {
+    return 1;
+  }
+  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+    return 1;
+  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+    return -1;
+  }
+  if (a === LABEL_REG_EXP_STR) {
+    return 1;
+  } else if (b === LABEL_REG_EXP_STR) {
+    return -1;
+  }
+  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+}
+var Node = class _Node {
+  #index;
+  #varIndex;
+  #children = /* @__PURE__ */ Object.create(null);
+  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
+    if (tokens.length === 0) {
+      if (this.#index !== void 0) {
+        throw PATH_ERROR;
+      }
+      if (pathErrorCheckOnly) {
+        return;
+      }
+      this.#index = index;
+      return;
+    }
+    const [token, ...restTokens] = tokens;
+    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+    let node;
+    if (pattern) {
+      const name = pattern[1];
+      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+      if (name && pattern[2]) {
+        if (regexpStr === ".*") {
+          throw PATH_ERROR;
+        }
+        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+        if (/\((?!\?:)/.test(regexpStr)) {
+          throw PATH_ERROR;
+        }
+      }
+      node = this.#children[regexpStr];
+      if (!node) {
+        if (Object.keys(this.#children).some(
+          (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.#children[regexpStr] = new _Node();
+        if (name !== "") {
+          node.#varIndex = context.varIndex++;
+        }
+      }
+      if (!pathErrorCheckOnly && name !== "") {
+        paramMap.push([name, node.#varIndex]);
+      }
+    } else {
+      node = this.#children[token];
+      if (!node) {
+        if (Object.keys(this.#children).some(
+          (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.#children[token] = new _Node();
+      }
+    }
+    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+  }
+  buildRegExpStr() {
+    const childKeys = Object.keys(this.#children).sort(compareKey);
+    const strList = childKeys.map((k) => {
+      const c = this.#children[k];
+      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+    });
+    if (typeof this.#index === "number") {
+      strList.unshift(`#${this.#index}`);
+    }
+    if (strList.length === 0) {
+      return "";
+    }
+    if (strList.length === 1) {
+      return strList[0];
+    }
+    return "(?:" + strList.join("|") + ")";
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/router/reg-exp-router/trie.js
+var Trie = class {
+  #context = { varIndex: 0 };
+  #root = new Node();
+  insert(path, index, pathErrorCheckOnly) {
+    const paramAssoc = [];
+    const groups = [];
+    for (let i = 0; ; ) {
+      let replaced = false;
+      path = path.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`;
+        groups[i] = [mark, m];
+        i++;
+        replaced = true;
+        return mark;
+      });
+      if (!replaced) {
+        break;
+      }
+    }
+    const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    for (let i = groups.length - 1; i >= 0; i--) {
+      const [mark] = groups[i];
+      for (let j = tokens.length - 1; j >= 0; j--) {
+        if (tokens[j].indexOf(mark) !== -1) {
+          tokens[j] = tokens[j].replace(mark, groups[i][1]);
+          break;
+        }
+      }
+    }
+    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
+    return paramAssoc;
+  }
+  buildRegExp() {
+    let regexp = this.#root.buildRegExpStr();
+    if (regexp === "") {
+      return [/^$/, [], []];
+    }
+    let captureIndex = 0;
+    const indexReplacementMap = [];
+    const paramReplacementMap = [];
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (handlerIndex !== void 0) {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (paramIndex !== void 0) {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/router/reg-exp-router/router.js
+var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
+var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+function buildWildcardRegExp(path) {
+  return wildcardRegExpCache[path] ??= new RegExp(
+    path === "*" ? "" : `^${path.replace(
+      /\/\*$|([.\\+*[^\]$()])/g,
+      (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
+    )}$`
+  );
+}
+function clearWildcardRegExpCache() {
+  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+}
+function buildMatcherFromPreprocessedRoutes(routes) {
+  const trie = new Trie();
+  const handlerData = [];
+  if (routes.length === 0) {
+    return nullMatcher;
+  }
+  const routesWithStaticPathFlag = routes.map(
+    (route) => [!/\*|\/:/.test(route[0]), ...route]
+  ).sort(
+    ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
+  );
+  const staticMap = /* @__PURE__ */ Object.create(null);
+  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
+    const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
+    if (pathErrorCheckOnly) {
+      staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+    } else {
+      j++;
+    }
+    let paramAssoc;
+    try {
+      paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
+    }
+    if (pathErrorCheckOnly) {
+      continue;
+    }
+    handlerData[j] = handlers.map(([h, paramCount]) => {
+      const paramIndexMap = /* @__PURE__ */ Object.create(null);
+      paramCount -= 1;
+      for (; paramCount >= 0; paramCount--) {
+        const [key, value] = paramAssoc[paramCount];
+        paramIndexMap[key] = value;
+      }
+      return [h, paramIndexMap];
+    });
+  }
+  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+  for (let i = 0, len = handlerData.length; i < len; i++) {
+    for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
+      const map = handlerData[i][j]?.[1];
+      if (!map) {
+        continue;
+      }
+      const keys = Object.keys(map);
+      for (let k = 0, len3 = keys.length; k < len3; k++) {
+        map[keys[k]] = paramReplacementMap[map[keys[k]]];
+      }
+    }
+  }
+  const handlerMap = [];
+  for (const i in indexReplacementMap) {
+    handlerMap[i] = handlerData[indexReplacementMap[i]];
+  }
+  return [regexp, handlerMap, staticMap];
+}
+function findMiddleware(middleware, path) {
+  if (!middleware) {
+    return void 0;
+  }
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path)) {
+      return [...middleware[k]];
+    }
+  }
+  return void 0;
+}
+var RegExpRouter = class {
+  name = "RegExpRouter";
+  #middleware;
+  #routes;
+  constructor() {
+    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+  }
+  add(method, path, handler) {
+    const middleware = this.#middleware;
+    const routes = this.#routes;
+    if (!middleware || !routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    if (!middleware[method]) {
+      ;
+      [middleware, routes].forEach((handlerMap) => {
+        handlerMap[method] = /* @__PURE__ */ Object.create(null);
+        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
+          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
+        });
+      });
+    }
+    if (path === "/*") {
+      path = "*";
+    }
+    const paramCount = (path.match(/\/:/g) || []).length;
+    if (/\*$/.test(path)) {
+      const re = buildWildcardRegExp(path);
+      if (method === METHOD_NAME_ALL) {
+        Object.keys(middleware).forEach((m) => {
+          middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+        });
+      } else {
+        middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+      }
+      Object.keys(middleware).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(middleware[m]).forEach((p) => {
+            re.test(p) && middleware[m][p].push([handler, paramCount]);
+          });
+        }
+      });
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(routes[m]).forEach(
+            (p) => re.test(p) && routes[m][p].push([handler, paramCount])
+          );
+        }
+      });
+      return;
+    }
+    const paths = checkOptionalParameter(path) || [path];
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const path2 = paths[i];
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          routes[m][path2] ||= [
+            ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
+          ];
+          routes[m][path2].push([handler, paramCount - len + i + 1]);
+        }
+      });
+    }
+  }
+  match = match;
+  buildAllMatchers() {
+    const matchers = /* @__PURE__ */ Object.create(null);
+    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
+      matchers[method] ||= this.#buildMatcher(method);
+    });
+    this.#middleware = this.#routes = void 0;
+    clearWildcardRegExpCache();
+    return matchers;
+  }
+  #buildMatcher(method) {
+    const routes = [];
+    let hasOwnRoute = method === METHOD_NAME_ALL;
+    [this.#middleware, this.#routes].forEach((r) => {
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
+      if (ownRoute.length !== 0) {
+        hasOwnRoute ||= true;
+        routes.push(...ownRoute);
+      } else if (method !== METHOD_NAME_ALL) {
+        routes.push(
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]])
+        );
+      }
+    });
+    if (!hasOwnRoute) {
+      return null;
+    } else {
+      return buildMatcherFromPreprocessedRoutes(routes);
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/router/smart-router/router.js
+var SmartRouter = class {
+  name = "SmartRouter";
+  #routers = [];
+  #routes = [];
+  constructor(init) {
+    this.#routers = init.routers;
+  }
+  add(method, path, handler) {
+    if (!this.#routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    this.#routes.push([method, path, handler]);
+  }
+  match(method, path) {
+    if (!this.#routes) {
+      throw new Error("Fatal error");
+    }
+    const routers = this.#routers;
+    const routes = this.#routes;
+    const len = routers.length;
+    let i = 0;
+    let res;
+    for (; i < len; i++) {
+      const router = routers[i];
+      try {
+        for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
+          router.add(...routes[i2]);
+        }
+        res = router.match(method, path);
+      } catch (e) {
+        if (e instanceof UnsupportedPathError) {
+          continue;
+        }
+        throw e;
+      }
+      this.match = router.match.bind(router);
+      this.#routers = [router];
+      this.#routes = void 0;
+      break;
+    }
+    if (i === len) {
+      throw new Error("Fatal error");
+    }
+    this.name = `SmartRouter + ${this.activeRouter.name}`;
+    return res;
+  }
+  get activeRouter() {
+    if (this.#routes || this.#routers.length !== 1) {
+      throw new Error("No active router has been determined yet.");
+    }
+    return this.#routers[0];
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/router/trie-router/node.js
+var emptyParams = /* @__PURE__ */ Object.create(null);
+var Node2 = class _Node2 {
+  #methods;
+  #children;
+  #patterns;
+  #order = 0;
+  #params = emptyParams;
+  constructor(method, handler, children) {
+    this.#children = children || /* @__PURE__ */ Object.create(null);
+    this.#methods = [];
+    if (method && handler) {
+      const m = /* @__PURE__ */ Object.create(null);
+      m[method] = { handler, possibleKeys: [], score: 0 };
+      this.#methods = [m];
+    }
+    this.#patterns = [];
+  }
+  insert(method, path, handler) {
+    this.#order = ++this.#order;
+    let curNode = this;
+    const parts = splitRoutingPath(path);
+    const possibleKeys = [];
+    for (let i = 0, len = parts.length; i < len; i++) {
+      const p = parts[i];
+      const nextP = parts[i + 1];
+      const pattern = getPattern(p, nextP);
+      const key = Array.isArray(pattern) ? pattern[0] : p;
+      if (key in curNode.#children) {
+        curNode = curNode.#children[key];
+        if (pattern) {
+          possibleKeys.push(pattern[1]);
+        }
+        continue;
+      }
+      curNode.#children[key] = new _Node2();
+      if (pattern) {
+        curNode.#patterns.push(pattern);
+        possibleKeys.push(pattern[1]);
+      }
+      curNode = curNode.#children[key];
+    }
+    curNode.#methods.push({
+      [method]: {
+        handler,
+        possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
+        score: this.#order
+      }
+    });
+    return curNode;
+  }
+  #getHandlerSets(node, method, nodeParams, params) {
+    const handlerSets = [];
+    for (let i = 0, len = node.#methods.length; i < len; i++) {
+      const m = node.#methods[i];
+      const handlerSet = m[method] || m[METHOD_NAME_ALL];
+      const processedSet = {};
+      if (handlerSet !== void 0) {
+        handlerSet.params = /* @__PURE__ */ Object.create(null);
+        handlerSets.push(handlerSet);
+        if (nodeParams !== emptyParams || params && params !== emptyParams) {
+          for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
+            const key = handlerSet.possibleKeys[i2];
+            const processed = processedSet[handlerSet.score];
+            handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
+            processedSet[handlerSet.score] = true;
+          }
         }
-        else if (arg.startsWith("--transport=")) {
-            transport = arg.split("=")[1].toLowerCase();
+      }
+    }
+    return handlerSets;
+  }
+  search(method, path) {
+    const handlerSets = [];
+    this.#params = emptyParams;
+    const curNode = this;
+    let curNodes = [curNode];
+    const parts = splitPath(path);
+    const curNodesQueue = [];
+    for (let i = 0, len = parts.length; i < len; i++) {
+      const part = parts[i];
+      const isLast = i === len - 1;
+      const tempNodes = [];
+      for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+        const node = curNodes[j];
+        const nextNode = node.#children[part];
+        if (nextNode) {
+          nextNode.#params = node.#params;
+          if (isLast) {
+            if (nextNode.#children["*"]) {
+              handlerSets.push(
+                ...this.#getHandlerSets(nextNode.#children["*"], method, node.#params)
+              );
+            }
+            handlerSets.push(...this.#getHandlerSets(nextNode, method, node.#params));
+          } else {
+            tempNodes.push(nextNode);
+          }
         }
-        else if (arg.startsWith("--port=")) {
-            const parsed = Number.parseInt(arg.split("=")[1], 10);
-            if (Number.isFinite(parsed)) {
-                port = parsed;
+        for (let k = 0, len3 = node.#patterns.length; k < len3; k++) {
+          const pattern = node.#patterns[k];
+          const params = node.#params === emptyParams ? {} : { ...node.#params };
+          if (pattern === "*") {
+            const astNode = node.#children["*"];
+            if (astNode) {
+              handlerSets.push(...this.#getHandlerSets(astNode, method, node.#params));
+              astNode.#params = params;
+              tempNodes.push(astNode);
             }
+            continue;
+          }
+          const [key, name, matcher] = pattern;
+          if (!part && !(matcher instanceof RegExp)) {
+            continue;
+          }
+          const child = node.#children[key];
+          const restPathString = parts.slice(i).join("/");
+          if (matcher instanceof RegExp) {
+            const m = matcher.exec(restPathString);
+            if (m) {
+              params[name] = m[0];
+              handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
+              if (Object.keys(child.#children).length) {
+                child.#params = params;
+                const componentCount = m[0].match(/\//)?.length ?? 0;
+                const targetCurNodes = curNodesQueue[componentCount] ||= [];
+                targetCurNodes.push(child);
+              }
+              continue;
+            }
+          }
+          if (matcher === true || matcher.test(part)) {
+            params[name] = part;
+            if (isLast) {
+              handlerSets.push(...this.#getHandlerSets(child, method, params, node.#params));
+              if (child.#children["*"]) {
+                handlerSets.push(
+                  ...this.#getHandlerSets(child.#children["*"], method, params, node.#params)
+                );
+              }
+            } else {
+              child.#params = params;
+              tempNodes.push(child);
+            }
+          }
         }
-        else if (arg === "--help" || arg === "-h") {
-            console.log(`
-Connpass MCP Server
+      }
+      curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
+    }
+    if (handlerSets.length > 1) {
+      handlerSets.sort((a, b) => {
+        return a.score - b.score;
+      });
+    }
+    return [handlerSets.map(({ handler, params }) => [handler, params])];
+  }
+};
 
-Usage: connpass-mcp-server [options]
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/router/trie-router/router.js
+var TrieRouter = class {
+  name = "TrieRouter";
+  #node;
+  constructor() {
+    this.#node = new Node2();
+  }
+  add(method, path, handler) {
+    const results = checkOptionalParameter(path);
+    if (results) {
+      for (let i = 0, len = results.length; i < len; i++) {
+        this.#node.insert(method, results[i], handler);
+      }
+      return;
+    }
+    this.#node.insert(method, path, handler);
+  }
+  match(method, path) {
+    return this.#node.search(method, path);
+  }
+};
 
-Options:
-  -t, --transport <type>  Transport type: http or sse (default: http)
-  -p, --port <number>     Port number for http/sse transports (default: 3000)
-  -h, --help             Show this help message
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/hono.js
+var Hono2 = class extends Hono {
+  /**
+   * Creates an instance of the Hono class.
+   *
+   * @param options - Optional configuration options for the Hono instance.
+   */
+  constructor(options = {}) {
+    super(options);
+    this.router = options.router ?? new SmartRouter({
+      routers: [new RegExpRouter(), new TrieRouter()]
+    });
+  }
+};
 
-Examples:
-  connpass-mcp-server                           # Start with HTTP transport on port 3000
-  connpass-mcp-server --transport sse --port 8080  # Start with SSE transport on port 8080
-  connpass-mcp-server -t http -p 5000          # Start with HTTP transport on port 5000
+// ../../node_modules/.pnpm/hono@4.11.3/node_modules/hono/dist/middleware/cors/index.js
+var cors = (options) => {
+  const defaults = {
+    origin: "*",
+    allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
+    allowHeaders: [],
+    exposeHeaders: []
+  };
+  const opts = {
+    ...defaults,
+    ...options
+  };
+  const findAllowOrigin = ((optsOrigin) => {
+    if (typeof optsOrigin === "string") {
+      if (optsOrigin === "*") {
+        return () => optsOrigin;
+      } else {
+        return (origin) => optsOrigin === origin ? origin : null;
+      }
+    } else if (typeof optsOrigin === "function") {
+      return optsOrigin;
+    } else {
+      return (origin) => optsOrigin.includes(origin) ? origin : null;
+    }
+  })(opts.origin);
+  const findAllowMethods = ((optsAllowMethods) => {
+    if (typeof optsAllowMethods === "function") {
+      return optsAllowMethods;
+    } else if (Array.isArray(optsAllowMethods)) {
+      return () => optsAllowMethods;
+    } else {
+      return () => [];
+    }
+  })(opts.allowMethods);
+  return async function cors2(c, next) {
+    function set(key, value) {
+      c.res.headers.set(key, value);
+    }
+    const allowOrigin = await findAllowOrigin(c.req.header("origin") || "", c);
+    if (allowOrigin) {
+      set("Access-Control-Allow-Origin", allowOrigin);
+    }
+    if (opts.credentials) {
+      set("Access-Control-Allow-Credentials", "true");
+    }
+    if (opts.exposeHeaders?.length) {
+      set("Access-Control-Expose-Headers", opts.exposeHeaders.join(","));
+    }
+    if (c.req.method === "OPTIONS") {
+      if (opts.origin !== "*") {
+        set("Vary", "Origin");
+      }
+      if (opts.maxAge != null) {
+        set("Access-Control-Max-Age", opts.maxAge.toString());
+      }
+      const allowMethods = await findAllowMethods(c.req.header("origin") || "", c);
+      if (allowMethods.length) {
+        set("Access-Control-Allow-Methods", allowMethods.join(","));
+      }
+      let headers = opts.allowHeaders;
+      if (!headers?.length) {
+        const requestHeaders = c.req.header("Access-Control-Request-Headers");
+        if (requestHeaders) {
+          headers = requestHeaders.split(/\s*,\s*/);
+        }
+      }
+      if (headers?.length) {
+        set("Access-Control-Allow-Headers", headers.join(","));
+        c.res.headers.append("Vary", "Access-Control-Request-Headers");
+      }
+      c.res.headers.delete("Content-Length");
+      c.res.headers.delete("Content-Type");
+      return new Response(null, {
+        headers: c.res.headers,
+        status: 204,
+        statusText: "No Content"
+      });
+    }
+    await next();
+    if (opts.origin !== "*") {
+      c.header("Vary", "Origin", { append: true });
+    }
+  };
+};
 
-Environment Variables:
-  CONNPASS_API_KEY                         Connpass API Key
-  CONNPASS_DEFAULT_USER_ID                 Default user ID
-  CONNPASS_INCLUDE_PRESENTATIONS_DEFAULT   Include presentations by default
-  CONNPASS_ENABLE_APPS_SDK_OUTPUT          Enable Apps SDK output
-  MCP_BASE_PATH                            MCP base path (for SSE transport)
-      `);
-            process.exit(0);
+// ../../packages/mcp-core/dist/http.js
+function badRequestError(message = "Bad Request: No valid session ID provided") {
+  return {
+    jsonrpc: "2.0",
+    error: { code: -32e3, message },
+    id: null
+  };
+}
+function internalServerError() {
+  return {
+    jsonrpc: "2.0",
+    error: { code: -32603, message: "Internal server error" },
+    id: null
+  };
+}
+function forbiddenError(message) {
+  return {
+    jsonrpc: "2.0",
+    error: { code: -32e3, message },
+    id: null
+  };
+}
+function unauthorizedError(message) {
+  return {
+    jsonrpc: "2.0",
+    error: { code: -32001, message },
+    id: null
+  };
+}
+function extractHostnameFromHostHeader(host) {
+  const trimmedHost = host.trim();
+  if (trimmedHost.startsWith("[")) {
+    const bracketEnd = trimmedHost.indexOf("]");
+    if (bracketEnd !== -1) {
+      return trimmedHost.slice(0, bracketEnd + 1);
+    }
+  }
+  const colonIndex = trimmedHost.indexOf(":");
+  if (colonIndex === -1) {
+    return trimmedHost;
+  }
+  return trimmedHost.slice(0, colonIndex);
+}
+function validateOrigin(config2) {
+  return async (c, next) => {
+    const origin = c.req.header("Origin");
+    if (!origin) {
+      return next();
+    }
+    try {
+      const originUrl = new URL(origin);
+      const originWithoutPort = `${originUrl.protocol}//${originUrl.hostname}`;
+      const isAllowed = config2.allowedOrigins.some((allowed) => {
+        try {
+          const allowedUrl = new URL(allowed);
+          return originWithoutPort === `${allowedUrl.protocol}//${allowedUrl.hostname}`;
+        } catch {
+          return false;
         }
+      });
+      if (!isAllowed) {
+        console.log(`Rejected request with invalid Origin: ${origin} (allowed: ${config2.allowedOrigins.join(", ")})`);
+        return c.json(forbiddenError("Forbidden: Invalid Origin header"), {
+          status: 403
+        });
+      }
+    } catch {
+      console.log(`Rejected request with malformed Origin: ${origin}`);
+      return c.json(forbiddenError("Forbidden: Malformed Origin header"), {
+        status: 403
+      });
     }
-    // Allow environment variable override for port
-    const envPort = Number.parseInt(process.env.PORT ?? "", 10);
-    if (Number.isFinite(envPort)) {
-        port = envPort;
+    return next();
+  };
+}
+function validateHost(config2) {
+  return async (c, next) => {
+    const host = c.req.header("Host");
+    if (!host) {
+      return next();
     }
-    // Allow environment variable override for transport
-    const envTransport = process.env.MCP_TRANSPORT?.toLowerCase();
-    if (envTransport) {
-        transport = envTransport;
+    const hostname = extractHostnameFromHostHeader(host);
+    if (!config2.allowedHosts.includes(hostname)) {
+      console.log(`Rejected request with invalid Host: ${host} (allowed: ${config2.allowedHosts.join(", ")})`);
+      return c.json(forbiddenError("Forbidden: Invalid Host header"), {
+        status: 403
+      });
     }
-    return { transport, port };
+    return next();
+  };
 }
-async function main() {
-    const { transport, port } = parseArgs();
-    switch (transport) {
-        case "http": {
-            await (0, http_js_1.startHttpServer)({
-                createMcpServer: createConnpassServer,
-                port,
-            });
-            break;
-        }
-        case "sse": {
-            const basePath = (0, config_js_1.getMcpBasePath)();
-            const messagePath = basePath === "/" ? "/messages" : `${basePath}/messages`;
-            await (0, sse_js_1.startSseServer)({
-                createMcpServer: createConnpassServer,
-                ssePath: basePath,
-                messagePath,
-                port,
-            });
-            break;
+function validateApiKey(config2) {
+  return async (c, next) => {
+    if (!config2.apiKey || c.req.method === "OPTIONS") {
+      return next();
+    }
+    const xApiKey = c.req.header("X-API-Key");
+    const authorization = c.req.header("Authorization");
+    const bearerToken = authorization?.startsWith("Bearer ") ? authorization.slice(7).trim() : void 0;
+    const providedKey = xApiKey ?? bearerToken;
+    if (providedKey !== config2.apiKey) {
+      console.log("Rejected request with invalid API key");
+      return c.json(unauthorizedError("Unauthorized: Invalid API key"), {
+        status: 401
+      });
+    }
+    return next();
+  };
+}
+function createHttpApp(options) {
+  const { server: server2, config: config2, serverFactory, extraCorsHeaders = [], onSessionInitialized, onSessionClosed } = options;
+  const transports = /* @__PURE__ */ new Map();
+  async function handleMCP(c) {
+    console.log(`Received ${c.req.method} request for MCP`);
+    const sessionId = c.req.header("mcp-session-id");
+    try {
+      if (sessionId && transports.has(sessionId)) {
+        console.log(`Reusing existing session: ${sessionId}`);
+        const transport = transports.get(sessionId);
+        return transport.handleRequest(c.req.raw);
+      }
+      if (c.req.method === "POST") {
+        let body;
+        try {
+          body = await c.req.json();
+        } catch {
+          return c.json(badRequestError("Invalid JSON"), { status: 400 });
+        }
+        if (isInitializeRequest(body)) {
+          console.log("Creating new WebStandard session");
+          const rawRequest = c.req.raw;
+          const transport = new WebStandardStreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (newSessionId) => {
+              console.log(`Session initialized: ${newSessionId}`);
+              transports.set(newSessionId, transport);
+              onSessionInitialized?.(newSessionId, rawRequest);
+            }
+          });
+          transport.onclose = () => {
+            const sid = transport.sessionId;
+            if (sid) {
+              console.log(`Transport closed for session: ${sid}`);
+              transports.delete(sid);
+              deleteSessionConfig(sid);
+              onSessionClosed?.(sid);
+            }
+          };
+          const sessionServer = serverFactory ? serverFactory() : server2;
+          await sessionServer.connect(transport);
+          return transport.handleRequest(c.req.raw, { parsedBody: body });
         }
-        default:
-            throw new Error(`Unsupported MCP transport: ${transport}. Use 'http' or 'sse'.`);
+      }
+      console.log("Invalid request - no session ID and not an initialize request");
+      return c.json(badRequestError(), { status: 400 });
+    } catch (e) {
+      console.error("MCP connection error:", e);
+      return c.json(internalServerError(), { status: 500 });
     }
+  }
+  function handleHealth(c) {
+    const response = {
+      status: "ok",
+      transports: transports.size,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return c.json(response);
+  }
+  const app = new Hono2();
+  const allowHeaders = [
+    "Content-Type",
+    "mcp-session-id",
+    "Last-Event-ID",
+    "mcp-protocol-version",
+    "X-API-Key",
+    "Authorization",
+    ...extraCorsHeaders
+  ];
+  app.use("/mcp", cors({
+    origin: "*",
+    allowMethods: ["GET", "POST", "DELETE", "OPTIONS"],
+    allowHeaders,
+    exposeHeaders: ["mcp-session-id", "mcp-protocol-version"]
+  }));
+  app.use("/mcp", validateOrigin(config2));
+  app.use("/mcp", validateHost(config2));
+  app.use("/mcp", validateApiKey(config2));
+  app.all("/mcp", handleMCP);
+  app.get("/health", handleHealth);
+  return app;
 }
-main().catch((error) => {
-    console.error("Server error:", error);
+
+// ../../packages/mcp-core/dist/stdio.js
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function connectStdio(server2) {
+  await server2.connect(new StdioServerTransport());
+}
+
+// ../../packages/mcp-core/dist/launcher.js
+function isNodejs() {
+  return typeof process !== "undefined" && !!process.versions?.node;
+}
+function isBun() {
+  return "Bun" in globalThis;
+}
+async function startHttpServer(options) {
+  const { server: server2, config: config2, serverName, serverFactory, httpOptions = {} } = options;
+  try {
+    console.error(`Starting ${serverName} HTTP server...`);
+    const app = createHttpApp({
+      server: server2,
+      config: config2,
+      serverFactory,
+      ...httpOptions
+    });
+    if (isBun()) {
+      const bunServer = Bun.serve({
+        fetch: app.fetch,
+        port: config2.httpPort,
+        hostname: config2.httpHost
+      });
+      console.error(`${serverName} HTTP server running at http://${bunServer.hostname}:${bunServer.port}/mcp`);
+      console.error(`Health check: http://${bunServer.hostname}:${bunServer.port}/health`);
+    } else {
+      const { serve: serve2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+      serve2({
+        fetch: app.fetch,
+        port: config2.httpPort,
+        hostname: config2.httpHost
+      }, (info) => {
+        console.error(`${serverName} HTTP server running at http://${info.address}:${info.port}/mcp`);
+        console.error(`Health check: http://${info.address}:${info.port}/health`);
+      });
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    console.error("HTTP server startup completed");
+  } catch (error) {
+    console.error("HTTP server startup failed:", error);
+    if (error instanceof Error) {
+      console.error("Error details:", {
+        message: error.message,
+        stack: error.stack,
+        name: error.name
+      });
+    }
+    throw new Error(`Failed to start HTTP server: ${error}`);
+  }
+}
+async function startStdioServer(options) {
+  try {
+    await connectStdio(options.server);
+    process.on("SIGINT", () => {
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("Stdio server startup failed:", error);
+    if (error instanceof Error) {
+      console.error("Error details:", {
+        message: error.message,
+        stack: error.stack,
+        name: error.name
+      });
+    }
+    throw new Error(`Failed to start stdio server: ${error}`);
+  }
+}
+async function launchServer(options) {
+  const { config: config2 } = options;
+  try {
+    if (config2.httpMode) {
+      await startHttpServer(options);
+    } else {
+      await startStdioServer(options);
+    }
+  } catch (error) {
+    console.error("Server startup failed:", error);
     process.exit(1);
+  }
+}
+
+// src/config.ts
+var connpassConfigDefs = {
+  connpassApiKey: {
+    cli: "--connpass-api-key",
+    env: "CONNPASS_API_KEY",
+    description: "Connpass API key",
+    group: "Connpass Configuration",
+    type: "string",
+    valueName: "<key>"
+  },
+  defaultUserId: {
+    cli: "--default-user-id",
+    env: "CONNPASS_DEFAULT_USER_ID",
+    description: "Default Connpass user ID for schedule search",
+    group: "Connpass Configuration",
+    type: "number",
+    valueName: "<id>"
+  },
+  rateLimitEnabled: {
+    cli: "--rate-limit",
+    env: "CONNPASS_RATE_LIMIT_ENABLED",
+    description: "Enable API rate limiting",
+    group: "Connpass Configuration",
+    type: "boolean",
+    default: true
+  },
+  rateLimitDelayMs: {
+    cli: "--rate-limit-delay",
+    env: "CONNPASS_RATE_LIMIT_DELAY_MS",
+    description: "Rate limit delay in milliseconds",
+    group: "Connpass Configuration",
+    type: "number",
+    default: 1e3,
+    valueName: "<ms>"
+  }
+};
+var allConfigDefs = {
+  ...connpassConfigDefs,
+  ...baseConfigDefs
+};
+function createDefaultConfig() {
+  const schemaDefs = getDefaultsFromDefs(allConfigDefs);
+  return schemaDefs;
+}
+function getConfig(argv, env) {
+  const cliConfig = parseCliFromDefs(
+    allConfigDefs,
+    argv ?? process.argv.slice(2)
+  );
+  const envConfig = parseEnvFromDefs(
+    allConfigDefs,
+    env ?? process.env
+  );
+  const defaultConfig = createDefaultConfig();
+  const merged = {
+    ...defaultConfig,
+    ...filterUndefined(envConfig),
+    ...filterUndefined(cliConfig)
+  };
+  return merged;
+}
+function getHelpText() {
+  return generateHelp(allConfigDefs, {
+    usage: "connpass-mcp-apps [options]",
+    examples: [
+      "CONNPASS_API_KEY=xxx connpass-mcp-apps",
+      "connpass-mcp-apps --http --port 8080",
+      "connpass-mcp-apps --connpass-api-key xxx --default-user-id 12345"
+    ]
+  });
+}
+
+// src/server.ts
+import { ConnpassClient } from "@kajidog/connpass-api-client";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/events.ts
+import { z as z2 } from "zod";
+
+// src/tools/prefectures.ts
+import {
+  getAllPrefectures,
+  normalizePrefecture
+} from "@kajidog/connpass-api-client";
+import { z } from "zod";
+
+// src/tools/utils/registration.ts
+import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
+function registerAppToolIfEnabled(server2, name, ...args) {
+  const [config2, cb] = args;
+  const normalizedConfig = {
+    ...config2,
+    _meta: config2._meta && typeof config2._meta === "object" ? config2._meta : {}
+  };
+  registerAppTool(server2, name, normalizedConfig, cb);
+}
+
+// src/tools/prefectures.ts
+var EmptyInputSchema = z.object({});
+function buildPrefectureListResult(invalid = []) {
+  const prefectures = getAllPrefectures();
+  const payload = {
+    invalid,
+    prefectures
+  };
+  const invalidText = invalid.length > 0 ? `\u6307\u5B9A\u3055\u308C\u305F\u90FD\u9053\u5E9C\u770C\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${invalid.join(", ")}
+` : "";
+  return {
+    content: [
+      {
+        type: "text",
+        text: `${invalidText}\u5229\u7528\u53EF\u80FD\u306A\u90FD\u9053\u5E9C\u770C\u4E00\u89A7: ${prefectures.map((item) => `${item.name} (${item.code})`).join(", ")}`
+      }
+    ],
+    structuredContent: {
+      kind: "prefectures",
+      data: payload
+    }
+  };
+}
+function resolvePrefectureInputs(values) {
+  if (!values) return {};
+  const inputs = Array.isArray(values) ? values : [values];
+  const prefectures = [];
+  const invalid = [];
+  for (const value of inputs) {
+    const normalized = normalizePrefecture(value);
+    if (!normalized) {
+      invalid.push(value);
+      continue;
+    }
+    prefectures.push(normalized);
+  }
+  if (invalid.length > 0) {
+    return { response: buildPrefectureListResult(invalid) };
+  }
+  return { prefectures };
+}
+function registerPrefectureTools(deps) {
+  const { server: server2 } = deps;
+  registerAppToolIfEnabled(
+    server2,
+    "list_prefectures",
+    {
+      title: "List Prefectures",
+      description: "List supported prefectures and region codes for filtering",
+      inputSchema: EmptyInputSchema
+    },
+    async () => buildPrefectureListResult()
+  );
+  registerAppToolIfEnabled(
+    server2,
+    "_get_prefectures",
+    {
+      title: "Get Prefectures (UI)",
+      description: "Internal: list supported prefectures for the UI",
+      inputSchema: EmptyInputSchema,
+      _meta: {
+        ui: {
+          visibility: ["app"]
+        }
+      }
+    },
+    async () => buildPrefectureListResult()
+  );
+}
+
+// src/tools/utils/formatting.ts
+var HTML_ENTITY_MAP = {
+  "&nbsp;": " ",
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#34;": '"',
+  "&#39;": "'",
+  "&#x27;": "'",
+  "&#x60;": "`"
+};
+var FORMAT_PRESETS = {
+  default: {
+    descriptionLimit: 0,
+    catchPhraseLimit: void 0
+  },
+  detailed: {
+    descriptionLimit: 200,
+    catchPhraseLimit: void 0
+  },
+  full: {
+    descriptionLimit: void 0,
+    catchPhraseLimit: void 0
+  }
+};
+function compactDateLabel(isoString) {
+  if (!isoString) return void 0;
+  const date = new Date(isoString);
+  if (Number.isNaN(date.getTime())) return void 0;
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function summarizeEventLine(event) {
+  const date = compactDateLabel(event.schedule.start);
+  const place = event.location?.place || event.location?.address;
+  const fragments = [
+    date,
+    event.title,
+    place ? `@ ${place}` : void 0
+  ].filter(Boolean);
+  return `- ${fragments.join(" ")}`;
+}
+function summarizeGroupLine(group) {
+  const place = [group.prefecture, group.place].filter(Boolean).join(" ");
+  const fragments = [
+    group.title?.trim(),
+    typeof group.id === "number" ? `id:${group.id}` : void 0,
+    place || void 0
+  ].filter(Boolean);
+  return `- ${fragments.join(" / ")}`;
+}
+function summarizeUserLine(user) {
+  const fragments = [
+    user.nickname?.trim(),
+    typeof user.id === "number" ? `id:${user.id}` : void 0,
+    user.displayName?.trim() ? `name:${user.displayName.trim()}` : void 0
+  ].filter(Boolean);
+  return `- ${fragments.join(" / ")}`;
+}
+function truncateText(text, limit) {
+  if (!text) return "";
+  if (text.length <= limit) return text;
+  if (limit <= 3) return text.slice(0, limit);
+  return `${text.slice(0, limit - 3).trimEnd()}...`;
+}
+function decodeHtmlEntities(input) {
+  return input.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (entity) => {
+    const mapped = HTML_ENTITY_MAP[entity];
+    if (mapped) return mapped;
+    const numericMatch = entity.match(/^&#(x?[0-9a-fA-F]+);$/);
+    if (!numericMatch) return entity;
+    const value = numericMatch[1];
+    const codePoint = value.startsWith("x") || value.startsWith("X") ? Number.parseInt(value.slice(1), 16) : Number.parseInt(value, 10);
+    if (!Number.isFinite(codePoint)) return entity;
+    try {
+      return String.fromCodePoint(codePoint);
+    } catch {
+      return entity;
+    }
+  }).replace(/\u00a0/gi, " ");
+}
+function stripHtml(input) {
+  if (!input) return "";
+  const withoutScripts = input.replace(/<script[\s\S]*?<\/script>/gi, "");
+  const withoutStyles = withoutScripts.replace(/<style[\s\S]*?<\/style>/gi, "");
+  const withCellBrNormalized = withoutStyles.replace(
+    /(<(?:td|th)\b[^>]*>)([\s\S]*?)(<\/(?:td|th)>)/gi,
+    (_, open, content, close) => `${open}${content.replace(/<br\s*\/?\s*>/gi, " ")}${close}`
+  );
+  const normalizedTableCells = withCellBrNormalized.replace(/<\/(td|th)>\s*<(td|th)/gi, "</$1>	<$2").replace(/<\/(tr)>\s*<tr/gi, "</$1>\n<tr");
+  const withLineBreaks = normalizedTableCells.replace(/<br\s*\/?\s*>/gi, "\n").replace(/<\/(p|div|section|article|header|footer|li)>/gi, "\n").replace(/<\/(td|th)>/gi, "	").replace(/<li[^>]*>/gi, "- ").replace(/<h[1-6]\b[^>]*>/gi, "\n## ").replace(/<\/(h[1-6]|tr)>/gi, "\n");
+  const withoutTags = withLineBreaks.replace(/<[^>]+>/g, "");
+  return decodeHtmlEntities(withoutTags);
+}
+function sanitizeRichText(input) {
+  if (!input) return "";
+  const stripped = stripHtml(input);
+  const normalizedWhitespace = stripped.replace(/\r/g, "\n").split(/\n+/).map(
+    (line) => line.split(/\t+/).map((cell) => cell.trim()).filter(Boolean).join("	")
+  ).filter(Boolean).join("\n");
+  return normalizedWhitespace.replace(/ {2,}/g, " ").replace(/ *\t */g, "	").trim();
+}
+function formatPresentation(presentation, descriptionLimit) {
+  const summary = sanitizeRichText(presentation.description);
+  const title = String(presentation.title ?? "").trim();
+  const speaker = String(presentation.speakerName ?? "").trim();
+  const formatted = {
+    id: presentation.id,
+    title: title || "Untitled presentation",
+    speaker: speaker || "Speaker unknown",
+    order: presentation.order,
+    updatedAt: presentation.updatedAt
+  };
+  const processedSummary = typeof descriptionLimit === "number" && descriptionLimit > 0 ? truncateText(summary, descriptionLimit) : summary;
+  if (processedSummary) {
+    formatted.summary = processedSummary;
+  }
+  const links = {
+    url: presentation.url,
+    slideshare: presentation.slideshareUrl,
+    youtube: presentation.youtubeUrl,
+    twitter: presentation.twitterUrl
+  };
+  if (links.url || links.slideshare || links.youtube || links.twitter) {
+    formatted.links = links;
+  }
+  return formatted;
+}
+function formatPresentationsResponse(response, options) {
+  const descriptionLimit = options?.presentationDescriptionLimit;
+  return {
+    returned: response.presentationsReturned,
+    presentations: response.presentations.map(
+      (presentation) => formatPresentation(presentation, descriptionLimit)
+    )
+  };
+}
+function formatEvent(event, options) {
+  const descriptionLimit = options?.descriptionLimit;
+  const catchPhraseLimit = options?.catchPhraseLimit;
+  const presentationDescriptionLimit = options?.presentationDescriptionLimit;
+  const catchPhrase = sanitizeRichText(event.catchPhrase);
+  const description = sanitizeRichText(event.description);
+  const participants = {
+    accepted: event.participantCount,
+    waiting: event.waitingCount
+  };
+  if (typeof event.limit === "number") {
+    participants.limit = event.limit;
+  }
+  const formatted = {
+    id: event.id,
+    title: event.title.trim(),
+    url: event.url,
+    schedule: {
+      start: event.startedAt,
+      end: event.endedAt
+    },
+    owner: {
+      nickname: event.ownerNickname,
+      displayName: event.ownerDisplayName
+    },
+    participants,
+    updatedAt: event.updatedAt
+  };
+  if (event.hashTag) formatted.hashTag = event.hashTag;
+  if (event.imageUrl) formatted.imageUrl = event.imageUrl;
+  const processedCatchPhrase = typeof catchPhraseLimit === "number" && catchPhraseLimit > 0 ? truncateText(catchPhrase, catchPhraseLimit) : catchPhrase;
+  if (processedCatchPhrase) formatted.catchPhrase = processedCatchPhrase;
+  const processedDescription = typeof descriptionLimit === "number" ? descriptionLimit > 0 ? truncateText(description, descriptionLimit) : "" : description;
+  if (processedDescription) formatted.summary = processedDescription;
+  if (event.place || event.address) {
+    const location = {};
+    if (event.place) location.place = event.place;
+    if (event.address) location.address = event.address;
+    if (Object.keys(location).length > 0) formatted.location = location;
+  }
+  if (event.groupId || event.groupTitle || event.groupUrl) {
+    const group = {};
+    if (typeof event.groupId === "number") group.id = event.groupId;
+    if (event.groupTitle) group.title = event.groupTitle;
+    if (event.groupUrl) group.url = event.groupUrl;
+    if (Object.keys(group).length > 0) formatted.group = group;
+  }
+  const eventWithPresentations = event;
+  if (eventWithPresentations.presentations?.length) {
+    formatted.presentations = eventWithPresentations.presentations.map(
+      (presentation) => formatPresentation(presentation, presentationDescriptionLimit)
+    );
+  }
+  return formatted;
+}
+function formatEventsResponse(response, options) {
+  return {
+    returned: response.eventsReturned,
+    available: response.eventsAvailable,
+    start: response.eventsStart,
+    events: response.events.map((event) => formatEvent(event, options))
+  };
+}
+function summarizeEventsResponse(response, label = "events") {
+  const lines = [
+    `${label}: ${response.returned} returned / ${response.available} available`,
+    ...response.events.slice(0, 5).map(summarizeEventLine)
+  ];
+  if (response.events.length > 5) {
+    lines.push(`- ...and ${response.events.length - 5} more`);
+  }
+  return lines.join("\n");
+}
+function summarizeGroupsResponse(response) {
+  const lines = [
+    `groups: ${response.groupsReturned} returned / ${response.groupsAvailable} available`,
+    ...response.groups.slice(0, 5).map(summarizeGroupLine)
+  ];
+  if (response.groups.length > 5) {
+    lines.push(`- ...and ${response.groups.length - 5} more`);
+  }
+  return lines.join("\n");
+}
+function summarizeUsersResponse(response) {
+  const lines = [
+    `users: ${response.usersReturned} returned / ${response.usersAvailable} available`,
+    ...response.users.slice(0, 5).map(summarizeUserLine)
+  ];
+  if (response.users.length > 5) {
+    lines.push(`- ...and ${response.users.length - 5} more`);
+  }
+  return lines.join("\n");
+}
+function formatEventList(events, options) {
+  return events.map((event) => formatEvent(event, options));
+}
+
+// src/tools/utils/resource.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import {
+  RESOURCE_MIME_TYPE,
+  registerAppResource
+} from "@modelcontextprotocol/ext-apps/server";
+var __dirname = typeof import.meta.dirname === "string" ? import.meta.dirname : dirname(fileURLToPath(import.meta.url));
+var connpassResourceUri = "ui://connpass/app.html";
+function loadConnpassHtml() {
+  try {
+    const htmlPath = join(__dirname, "mcp-app.html");
+    return readFileSync(htmlPath, "utf-8");
+  } catch {
+    try {
+      const htmlPath = join(
+        __dirname,
+        "..",
+        "..",
+        "node_modules",
+        "@kajidog",
+        "connpass-ui",
+        "dist",
+        "mcp-app.html"
+      );
+      return readFileSync(htmlPath, "utf-8");
+    } catch {
+      console.error(
+        "Warning: connpass-ui HTML not found. Please build @kajidog/connpass-ui first."
+      );
+      return "<html><body><p>Connpass UI not available. Please build @kajidog/connpass-ui.</p></body></html>";
+    }
+  }
+}
+var connpassHtml = loadConnpassHtml();
+function registerConnpassResource(deps) {
+  const { server: server2 } = deps;
+  registerAppResource(
+    server2,
+    "Connpass App",
+    connpassResourceUri,
+    {
+      description: "Interactive Connpass event browser",
+      mimeType: RESOURCE_MIME_TYPE
+    },
+    async () => ({
+      contents: [
+        {
+          uri: connpassResourceUri,
+          mimeType: RESOURCE_MIME_TYPE,
+          text: connpassHtml,
+          _meta: {
+            ui: {
+              csp: {
+                resourceDomains: [
+                  "https://connpass.com",
+                  "https://media.connpass.com"
+                ]
+              }
+            }
+          }
+        }
+      ]
+    })
+  );
+}
+
+// src/tools/utils/shared.ts
+var DEFAULT_PAGE_SIZE = 20;
+var EVENT_SORT_KEYS = [
+  "start-date-asc",
+  "start-date-desc",
+  "newly-added"
+];
+var EVENT_SORT_MAP = {
+  "start-date-asc": 1,
+  "start-date-desc": 2,
+  "newly-added": 3
+};
+var GROUP_SORT_KEYS = [
+  "most-events",
+  "most-members",
+  "newly-added"
+];
+var GROUP_SORT_MAP = {
+  "most-events": 1,
+  "most-members": 2,
+  "newly-added": 3
+};
+var USER_SORT_KEYS = [
+  "most-events",
+  "most-followers",
+  "newly-added"
+];
+var USER_SORT_MAP = {
+  "most-events": 1,
+  "most-followers": 2,
+  "newly-added": 3
+};
+function formatAsCompactYmd(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}${month}${day}`;
+}
+function formatAsHyphenatedYmd(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function parseDateInput(input, options) {
+  const normalized = input.trim();
+  const hyphenFree = normalized.replace(/[-/.]/g, "");
+  if (/^\d{8}$/.test(hyphenFree)) {
+    const year = Number(hyphenFree.slice(0, 4));
+    const month = Number(hyphenFree.slice(4, 6)) - 1;
+    const day = Number(hyphenFree.slice(6, 8));
+    const candidate = new Date(Date.UTC(year, month, day));
+    if (!Number.isNaN(candidate.getTime())) {
+      return options?.style === "hyphenated" ? formatAsHyphenatedYmd(candidate) : formatAsCompactYmd(candidate);
+    }
+  }
+  throw new Error(
+    `Invalid date format: ${input}. Expected YYYY-MM-DD or YYYYMMDD format.`
+  );
+}
+function toYmdArray(value) {
+  if (!value) return void 0;
+  const inputs = Array.isArray(value) ? value : [value];
+  return inputs.map((item) => parseDateInput(item));
+}
+function parseHyphenatedDate(input) {
+  const parsed = parseDateInput(input, { style: "hyphenated" });
+  if (/^\d{4}-\d{2}-\d{2}$/.test(parsed)) return parsed;
+  const digitsOnly = parsed.replace(/[^0-9]/g, "");
+  if (digitsOnly.length === 8) {
+    return `${digitsOnly.slice(0, 4)}-${digitsOnly.slice(4, 6)}-${digitsOnly.slice(6, 8)}`;
+  }
+  throw new Error(`Could not convert date input to YYYY-MM-DD: ${input}`);
+}
+function normalizeStringArray(value) {
+  if (!value) return void 0;
+  return Array.isArray(value) ? value : [value];
+}
+function normalizeKeywordOr(value) {
+  if (!value) return void 0;
+  const tokens = value.split(/[、,]+/).map((item) => item.trim()).filter(Boolean);
+  if (tokens.length === 0) return void 0;
+  return tokens.join(",");
+}
+function applyPagination(page, pageSize, options) {
+  const includePagination = options?.includePagination ?? true;
+  if (!includePagination) return {};
+  const effectivePageSize = pageSize ?? DEFAULT_PAGE_SIZE;
+  const pagination = {};
+  if (page) {
+    pagination.start = 1 + (page - 1) * effectivePageSize;
+    pagination.count = effectivePageSize;
+  } else if (pageSize) {
+    pagination.count = effectivePageSize;
+  }
+  return pagination;
+}
+
+// src/tools/events.ts
+var EventSearchInputSchema = z2.object({
+  anyQuery: z2.string().min(1).describe("Search keywords (comma-separated, matches ANY keyword)").optional(),
+  on: z2.union([z2.string().min(1), z2.array(z2.string().min(1))]).describe("Specific date(s) in YYYY-MM-DD or YYYYMMDD format").optional(),
+  from: z2.string().min(1).describe("Start of date range (inclusive). Format: YYYY-MM-DD").optional(),
+  to: z2.string().min(1).describe("End of date range (inclusive). Format: YYYY-MM-DD").optional(),
+  participantNickname: z2.string().min(1).describe("Filter by participant nickname").optional(),
+  hostNickname: z2.string().min(1).describe("Filter by host/owner nickname").optional(),
+  groupIds: z2.array(z2.number()).describe("Limit results to specific group IDs").optional(),
+  prefectures: z2.union([z2.string().min(1), z2.array(z2.string().min(1))]).describe("Prefecture name(s) to filter by").optional(),
+  page: z2.number().int().min(1).describe("1-based page number").optional(),
+  pageSize: z2.number().int().min(1).max(100).describe("Events per page (default 20, max 100)").optional(),
+  sort: z2.enum(EVENT_SORT_KEYS).describe("Sort order").optional(),
+  includeDetails: z2.boolean().describe(
+    "Include event description (up to 200 chars). Use when you need content details for recommendations."
+  ).default(false).optional()
+});
+var EventPresentationsInputSchema = z2.object({
+  eventId: z2.union([z2.number().int().positive(), z2.string().min(1)]).describe("Connpass event ID").transform((value) => Number(value)).refine((value) => Number.isFinite(value), "eventId must be a number")
+});
+function buildEventSearchParams(input) {
+  const pagination = applyPagination(input.page, input.pageSize);
+  const resolved = resolvePrefectureInputs(input.prefectures);
+  if ("response" in resolved) {
+    return resolved;
+  }
+  return {
+    keywordOr: normalizeKeywordOr(input.anyQuery),
+    ymd: toYmdArray(input.on),
+    ymdFrom: input.from ? parseHyphenatedDate(input.from) : void 0,
+    ymdTo: input.to ? parseHyphenatedDate(input.to) : void 0,
+    nickname: input.participantNickname,
+    ownerNickname: input.hostNickname,
+    groupId: input.groupIds,
+    prefecture: resolved.prefectures ?? normalizeStringArray(input.prefectures),
+    order: input.sort ? EVENT_SORT_MAP[input.sort] : void 0,
+    ...pagination
+  };
+}
+var LIST_FORMAT_OPTIONS = {
+  descriptionLimit: 0,
+  catchPhraseLimit: 100
+};
+function registerEventTools(deps) {
+  const { server: server2, connpassClient, searchSessionStore } = deps;
+  const searchEventsHandler = async (args) => {
+    const params = EventSearchInputSchema.parse(args ?? {});
+    const searchParams = buildEventSearchParams(params);
+    if ("response" in searchParams) {
+      return {
+        ...searchParams.response,
+        isError: true
+      };
+    }
+    const response = await connpassClient.searchEvents(searchParams);
+    const formatOptions = params.includeDetails ? FORMAT_PRESETS.detailed : FORMAT_PRESETS.default;
+    const formatted = formatEventsResponse(response, formatOptions);
+    const browseFormatted = formatEventsResponse(response, LIST_FORMAT_OPTIONS);
+    const searchSessionId = searchSessionStore.save(browseFormatted);
+    return {
+      content: [
+        {
+          type: "text",
+          text: summarizeEventsResponse(formatted)
+        }
+      ],
+      structuredContent: {
+        kind: "events",
+        searchSessionId,
+        data: formatted
+      }
+    };
+  };
+  registerAppToolIfEnabled(
+    server2,
+    "search_events",
+    {
+      title: "Search Events",
+      description: "Search Connpass events and return results as text for reasoning and recommendations. Use this whenever the user asks about events.",
+      inputSchema: EventSearchInputSchema
+    },
+    searchEventsHandler
+  );
+  registerAppToolIfEnabled(
+    server2,
+    "browse_events",
+    {
+      title: "Browse Events",
+      description: "Display previously searched events in the interactive event browser UI. Use this proactively when the user wants to browse event options, scan many candidates, compare events, or inspect results visually. The UI lets the user refine and re-run searches directly, so prefer this for event exploration. Call this ONCE with the searchSessionId returned by search_events. Do not use this to search again.",
+      inputSchema: z2.object({
+        searchSessionId: z2.uuid().describe("Session ID returned by search_events")
+      }),
+      _meta: {
+        ui: { resourceUri: connpassResourceUri }
+      }
+    },
+    async (args) => {
+      const { searchSessionId } = z2.object({
+        searchSessionId: z2.uuid()
+      }).parse(args ?? {});
+      const formatted = searchSessionStore.get(searchSessionId);
+      if (!formatted) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Search session not found or expired. Run search_events again, then call browse_events once with the returned searchSessionId."
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          { type: "text", text: summarizeEventsResponse(formatted) }
+        ],
+        structuredContent: {
+          kind: "events",
+          searchSessionId,
+          data: formatted
+        }
+      };
+    }
+  );
+  registerAppToolIfEnabled(
+    server2,
+    "get_event_presentations",
+    {
+      title: "Get Event Presentations",
+      description: "Look up presentation details for a specific event",
+      inputSchema: EventPresentationsInputSchema
+    },
+    async (args) => {
+      const { eventId } = EventPresentationsInputSchema.parse(args ?? {});
+      const response = await connpassClient.getEventPresentations(eventId);
+      const formatted = formatPresentationsResponse(response);
+      return {
+        content: [{ type: "text", text: JSON.stringify(formatted) }]
+      };
+    }
+  );
+  registerAppToolIfEnabled(
+    server2,
+    "get_event_detail",
+    {
+      title: "Get Event Detail",
+      description: "Get full details of a specific event by ID, including complete description and presentations",
+      inputSchema: EventPresentationsInputSchema
+    },
+    async (args) => {
+      const { eventId } = EventPresentationsInputSchema.parse(args ?? {});
+      const [eventsResponse, presentationsResponse] = await Promise.all([
+        connpassClient.searchEvents({ eventId: [eventId], count: 1 }),
+        connpassClient.getEventPresentations(eventId).catch(() => void 0)
+      ]);
+      const event = eventsResponse.events[0];
+      if (!event) {
+        throw new Error(`Event with ID ${eventId} not found.`);
+      }
+      const formatted = formatEvent(event, FORMAT_PRESETS.full);
+      const presentations = presentationsResponse ? formatPresentationsResponse(presentationsResponse) : void 0;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ event: formatted, presentations })
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/groups.ts
+import { z as z3 } from "zod";
+var GroupSearchInputSchema = z3.object({
+  query: z3.string().min(1).describe("Keywords matching group title or description").optional(),
+  groupIds: z3.array(z3.number()).describe("Limit to specific group IDs").optional(),
+  country: z3.string().min(1).describe("ISO country code, e.g. 'JP'").optional(),
+  prefecture: z3.string().min(1).describe("Prefecture name to filter by").optional(),
+  page: z3.number().int().min(1).describe("1-based page number").optional(),
+  pageSize: z3.number().int().min(1).max(100).describe("Groups per page (default 20)").optional(),
+  sort: z3.enum(GROUP_SORT_KEYS).describe("Ranking by activity, members, or recency").optional()
+});
+function buildGroupSearchParams(input) {
+  const pagination = applyPagination(input.page, input.pageSize);
+  const resolved = resolvePrefectureInputs(input.prefecture);
+  if ("response" in resolved) {
+    return resolved;
+  }
+  return {
+    keyword: input.query,
+    groupId: input.groupIds,
+    countryCode: input.country,
+    prefecture: resolved.prefectures?.[0] ?? input.prefecture,
+    order: input.sort ? GROUP_SORT_MAP[input.sort] : void 0,
+    ...pagination
+  };
+}
+function registerGroupTools(deps) {
+  const { server: server2, connpassClient } = deps;
+  registerAppToolIfEnabled(
+    server2,
+    "search_groups",
+    {
+      title: "Search Groups",
+      description: "Find Connpass groups with simple filters",
+      inputSchema: GroupSearchInputSchema
+    },
+    async (args) => {
+      const params = GroupSearchInputSchema.parse(args ?? {});
+      const searchParams = buildGroupSearchParams(params);
+      if ("response" in searchParams) {
+        return {
+          ...searchParams.response,
+          isError: true
+        };
+      }
+      const response = await connpassClient.searchGroups(searchParams);
+      return {
+        content: [
+          { type: "text", text: summarizeGroupsResponse(response) }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/schedule.ts
+import { z as z4 } from "zod";
+var ScheduleInputSchema = z4.object({
+  userId: z4.number().int().positive().describe("Connpass user ID").optional(),
+  nickname: z4.string().min(1).describe("Connpass user nickname").optional(),
+  fromDate: z4.string().min(1).describe("Start date (YYYY-MM-DD). Defaults to today.").optional(),
+  toDate: z4.string().min(1).describe("End date (YYYY-MM-DD). Defaults to +7 days.").optional(),
+  maxEvents: z4.number().int().min(1).max(100).describe("Maximum events to check (default 30)").optional(),
+  includeDetails: z4.boolean().describe("Include event description (up to 200 chars)").default(false).optional()
+});
+function startOfDay(date) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+function formatDateLabel(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function registerScheduleTools(deps) {
+  const { server: server2, connpassClient, config: config2 } = deps;
+  registerAppToolIfEnabled(
+    server2,
+    "search_schedule",
+    {
+      title: "Search Schedule",
+      description: "Search user's schedule - events within a date range",
+      inputSchema: ScheduleInputSchema,
+      _meta: {
+        ui: { resourceUri: connpassResourceUri }
+      }
+    },
+    async (args) => {
+      const parsed = ScheduleInputSchema.parse(args ?? {});
+      let resolvedUserId = parsed.userId ?? config2.defaultUserId;
+      let userNickname;
+      if (parsed.nickname) {
+        const userSearchResponse = await connpassClient.searchUsers({
+          nickname: parsed.nickname
+        });
+        if (userSearchResponse.users.length === 0) {
+          throw new Error(`User with nickname "${parsed.nickname}" not found.`);
+        }
+        resolvedUserId = userSearchResponse.users[0].id;
+        userNickname = userSearchResponse.users[0].nickname;
+      }
+      if (!resolvedUserId) {
+        throw new Error(
+          "User ID or nickname is required. Pass userId, nickname, or set CONNPASS_DEFAULT_USER_ID."
+        );
+      }
+      const maxEventsToFetch = parsed.maxEvents ?? 30;
+      const today = startOfDay(/* @__PURE__ */ new Date());
+      const rangeStart = parsed.fromDate ? startOfDay(new Date(parseHyphenatedDate(parsed.fromDate))) : today;
+      const rangeEnd = parsed.toDate ? startOfDay(new Date(parseHyphenatedDate(parsed.toDate))) : (() => {
+        const defaultEnd = new Date(rangeStart);
+        defaultEnd.setDate(defaultEnd.getDate() + 7);
+        return defaultEnd;
+      })();
+      rangeEnd.setHours(23, 59, 59, 999);
+      if (!userNickname) {
+        const userResponse = await connpassClient.searchUsers({
+          userId: [resolvedUserId]
+        });
+        if (userResponse.users.length === 0) {
+          throw new Error(`User with ID ${resolvedUserId} not found.`);
+        }
+        userNickname = userResponse.users.find(
+          (u) => u.id === resolvedUserId
+        )?.nickname;
+        if (!userNickname)
+          throw new Error(`User with ID ${resolvedUserId} not found.`);
+      }
+      const searchResponse = await connpassClient.searchEvents({
+        nickname: userNickname,
+        ymdFrom: formatDateLabel(rangeStart),
+        ymdTo: formatDateLabel(rangeEnd),
+        order: EVENT_SORT_MAP["start-date-asc"],
+        count: maxEventsToFetch
+      });
+      const eventsByDate = /* @__PURE__ */ new Map();
+      for (const event of searchResponse.events) {
+        const eventDate = formatDateLabel(
+          startOfDay(new Date(event.startedAt))
+        );
+        if (!eventsByDate.has(eventDate)) {
+          eventsByDate.set(eventDate, []);
+        }
+        eventsByDate.get(eventDate).push(event);
+      }
+      const sortedDates = Array.from(eventsByDate.keys()).sort();
+      const sections = sortedDates.map((date) => ({
+        date,
+        events: formatEventList(
+          eventsByDate.get(date),
+          parsed.includeDetails ? FORMAT_PRESETS.detailed : FORMAT_PRESETS.default
+        )
+      }));
+      const result = {
+        userId: resolvedUserId,
+        sections,
+        metadata: {
+          fromDate: formatDateLabel(rangeStart),
+          toDate: formatDateLabel(rangeEnd),
+          inspected: searchResponse.eventsReturned,
+          limit: maxEventsToFetch
+        }
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: summarizeEventsResponse(
+              {
+                returned: sections.reduce(
+                  (count, section) => count + section.events.length,
+                  0
+                ),
+                available: sections.reduce(
+                  (count, section) => count + section.events.length,
+                  0
+                ),
+                start: 1,
+                events: sections.flatMap((section) => section.events)
+              },
+              "schedule"
+            )
+          }
+        ],
+        structuredContent: {
+          kind: "schedule",
+          data: result
+        }
+      };
+    }
+  );
+}
+
+// src/tools/ui-tools/detail.ts
+import { z as z5 } from "zod";
+var UIEventDetailInputSchema = z5.object({
+  eventId: z5.number().int().positive()
+});
+function registerUIEventDetailTool(deps) {
+  const { server: server2, connpassClient } = deps;
+  registerAppToolIfEnabled(
+    server2,
+    "_get_event_detail",
+    {
+      title: "Get Event Detail (UI)",
+      description: "Internal: fetch full event details for the detail view",
+      inputSchema: UIEventDetailInputSchema,
+      _meta: {
+        ui: {
+          resourceUri: connpassResourceUri,
+          visibility: ["app"]
+        }
+      }
+    },
+    async (args) => {
+      const { eventId } = UIEventDetailInputSchema.parse(args ?? {});
+      const [eventsResponse, presentationsResponse] = await Promise.all([
+        connpassClient.searchEvents({
+          eventId: [eventId],
+          count: 1
+        }),
+        connpassClient.getEventPresentations(eventId).catch(() => void 0)
+      ]);
+      const event = eventsResponse.events[0];
+      if (!event) {
+        throw new Error(`Event with ID ${eventId} not found.`);
+      }
+      const formatted = formatEvent(event);
+      const presentations = presentationsResponse ? formatPresentationsResponse(presentationsResponse) : void 0;
+      const detailEvent = presentations?.presentations?.length ? { ...formatted, presentations: presentations.presentations } : formatted;
+      return {
+        content: [{ type: "text", text: JSON.stringify(detailEvent) }],
+        structuredContent: {
+          kind: "event-detail",
+          data: {
+            event: detailEvent,
+            presentations
+          }
+        }
+      };
+    }
+  );
+}
+
+// src/tools/ui-tools/schedule.ts
+import { z as z6 } from "zod";
+var UIScheduleInputSchema = z6.object({
+  userId: z6.number().int().positive().optional(),
+  nickname: z6.string().min(1).optional(),
+  fromDate: z6.string().min(1).optional(),
+  toDate: z6.string().min(1).optional(),
+  maxEvents: z6.number().int().min(1).max(100).optional()
+});
+function startOfDay2(date) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+function formatDateLabel2(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+var SCHEDULE_FORMAT_OPTIONS = {
+  descriptionLimit: 0,
+  catchPhraseLimit: 100
+};
+var userNicknameCache = /* @__PURE__ */ new Map();
+function registerUIScheduleTool(deps) {
+  const { server: server2, connpassClient, config: config2 } = deps;
+  registerAppToolIfEnabled(
+    server2,
+    "_search_schedule",
+    {
+      title: "Search Schedule (UI)",
+      description: "Internal: re-search schedule from UI",
+      inputSchema: UIScheduleInputSchema,
+      _meta: {
+        ui: {
+          resourceUri: connpassResourceUri,
+          visibility: ["app"]
+        }
+      }
+    },
+    async (args) => {
+      const parsed = UIScheduleInputSchema.parse(args ?? {});
+      let resolvedUserId = parsed.userId ?? config2.defaultUserId;
+      let userNickname;
+      if (parsed.nickname) {
+        const userSearchResponse = await connpassClient.searchUsers({
+          nickname: parsed.nickname
+        });
+        if (userSearchResponse.users.length === 0) {
+          throw new Error(`User with nickname "${parsed.nickname}" not found.`);
+        }
+        resolvedUserId = userSearchResponse.users[0].id;
+        userNickname = userSearchResponse.users[0].nickname;
+        userNicknameCache.set(resolvedUserId, userNickname);
+      }
+      if (!resolvedUserId) {
+        throw new Error("User ID or nickname is required.");
+      }
+      const maxEventsToFetch = parsed.maxEvents ?? 30;
+      const today = startOfDay2(/* @__PURE__ */ new Date());
+      const rangeStart = parsed.fromDate ? startOfDay2(new Date(parseHyphenatedDate(parsed.fromDate))) : today;
+      const rangeEnd = parsed.toDate ? startOfDay2(new Date(parseHyphenatedDate(parsed.toDate))) : (() => {
+        const defaultEnd = new Date(rangeStart);
+        defaultEnd.setDate(defaultEnd.getDate() + 7);
+        return defaultEnd;
+      })();
+      rangeEnd.setHours(23, 59, 59, 999);
+      if (!userNickname) {
+        userNickname = userNicknameCache.get(resolvedUserId);
+        if (!userNickname) {
+          const userResponse = await connpassClient.searchUsers({
+            userId: [resolvedUserId]
+          });
+          if (userResponse.users.length === 0)
+            throw new Error(`User with ID ${resolvedUserId} not found.`);
+          userNickname = userResponse.users.find(
+            (u) => u.id === resolvedUserId
+          )?.nickname;
+          if (!userNickname)
+            throw new Error(`User with ID ${resolvedUserId} not found.`);
+          userNicknameCache.set(resolvedUserId, userNickname);
+        }
+      }
+      const searchResponse = await connpassClient.searchEvents({
+        nickname: userNickname,
+        ymdFrom: formatDateLabel2(rangeStart),
+        ymdTo: formatDateLabel2(rangeEnd),
+        order: EVENT_SORT_MAP["start-date-asc"],
+        count: maxEventsToFetch
+      });
+      const eventsByDate = /* @__PURE__ */ new Map();
+      for (const event of searchResponse.events) {
+        const eventDate = formatDateLabel2(
+          startOfDay2(new Date(event.startedAt))
+        );
+        if (!eventsByDate.has(eventDate)) eventsByDate.set(eventDate, []);
+        eventsByDate.get(eventDate).push(event);
+      }
+      const sortedDates = Array.from(eventsByDate.keys()).sort();
+      const sections = sortedDates.map((date) => ({
+        date,
+        events: formatEventList(
+          eventsByDate.get(date),
+          SCHEDULE_FORMAT_OPTIONS
+        )
+      }));
+      const result = {
+        userId: resolvedUserId,
+        sections,
+        metadata: {
+          fromDate: formatDateLabel2(rangeStart),
+          toDate: formatDateLabel2(rangeEnd),
+          inspected: searchResponse.eventsReturned,
+          limit: maxEventsToFetch
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        structuredContent: {
+          kind: "schedule",
+          data: result
+        }
+      };
+    }
+  );
+}
+
+// src/tools/ui-tools/search.ts
+import { z as z7 } from "zod";
+var UI_LIST_FORMAT_OPTIONS = {
+  descriptionLimit: 0,
+  catchPhraseLimit: 100
+};
+var UIEventSearchInputSchema = z7.object({
+  query: z7.string().min(1).optional(),
+  anyQuery: z7.string().min(1).optional(),
+  on: z7.union([z7.string().min(1), z7.array(z7.string().min(1))]).optional(),
+  from: z7.string().min(1).optional(),
+  to: z7.string().min(1).optional(),
+  participantNickname: z7.string().min(1).optional(),
+  hostNickname: z7.string().min(1).optional(),
+  groupIds: z7.array(z7.number()).optional(),
+  prefectures: z7.union([z7.string().min(1), z7.array(z7.string().min(1))]).optional(),
+  companyQuery: z7.string().min(1).optional(),
+  minAccepted: z7.number().int().min(0).optional(),
+  maxAccepted: z7.number().int().min(0).optional(),
+  minCapacity: z7.number().int().min(0).optional(),
+  maxCapacity: z7.number().int().min(0).optional(),
+  page: z7.number().int().min(1).optional(),
+  pageSize: z7.number().int().min(1).max(100).optional(),
+  sort: z7.enum(["start-date-asc", "participant-count-desc", "title-asc"]).optional()
+});
+function includesNormalized(targets, query) {
+  if (!query) return true;
+  const normalizedQuery = query.trim().toLowerCase();
+  if (!normalizedQuery) return true;
+  return targets.some(
+    (value) => value?.toLowerCase().includes(normalizedQuery)
+  );
+}
+function applyLocalFilters(events, params) {
+  return events.filter((event) => {
+    if (!includesNormalized(
+      [event.ownerDisplayName, event.groupTitle],
+      params.companyQuery
+    )) {
+      return false;
+    }
+    if (typeof params.minAccepted === "number" && event.participantCount < params.minAccepted) {
+      return false;
+    }
+    if (typeof params.maxAccepted === "number" && event.participantCount > params.maxAccepted) {
+      return false;
+    }
+    if (typeof params.minCapacity === "number") {
+      const limit = typeof event.limit === "number" ? event.limit : 0;
+      if (limit < params.minCapacity) return false;
+    }
+    if (typeof params.maxCapacity === "number") {
+      const limit = typeof event.limit === "number" ? event.limit : 0;
+      if (limit > params.maxCapacity) return false;
+    }
+    return true;
+  });
+}
+function sortEvents(events, sort) {
+  const copied = [...events];
+  copied.sort((a, b) => {
+    if (sort === "participant-count-desc") {
+      return b.participantCount - a.participantCount || a.startedAt.localeCompare(b.startedAt);
+    }
+    if (sort === "title-asc") {
+      return a.title.localeCompare(b.title, "ja") || a.startedAt.localeCompare(b.startedAt);
+    }
+    return a.startedAt.localeCompare(b.startedAt);
+  });
+  return copied;
+}
+function registerUISearchTool(deps) {
+  const { server: server2, connpassClient } = deps;
+  registerAppToolIfEnabled(
+    server2,
+    "_search_events",
+    {
+      title: "Search Events (UI)",
+      description: "Internal: re-search events from UI",
+      inputSchema: UIEventSearchInputSchema,
+      _meta: {
+        ui: {
+          resourceUri: connpassResourceUri,
+          visibility: ["app"]
+        }
+      }
+    },
+    async (args) => {
+      const params = UIEventSearchInputSchema.parse(args ?? {});
+      const useLocalFiltering = Boolean(params.companyQuery) || typeof params.minAccepted === "number" || typeof params.maxAccepted === "number" || typeof params.minCapacity === "number" || typeof params.maxCapacity === "number" || params.sort === "participant-count-desc" || params.sort === "title-asc";
+      const pagination = useLocalFiltering ? {} : applyPagination(params.page, params.pageSize);
+      const resolved = resolvePrefectureInputs(params.prefectures);
+      if ("response" in resolved) {
+        return {
+          ...resolved.response,
+          isError: true
+        };
+      }
+      const searchParams = {
+        keyword: params.query,
+        keywordOr: normalizeKeywordOr(params.anyQuery),
+        ymd: toYmdArray(params.on),
+        ymdFrom: params.from ? parseHyphenatedDate(params.from) : void 0,
+        ymdTo: params.to ? parseHyphenatedDate(params.to) : void 0,
+        nickname: params.participantNickname,
+        ownerNickname: params.hostNickname,
+        groupId: params.groupIds,
+        prefecture: resolved.prefectures ?? normalizeStringArray(params.prefectures),
+        order: EVENT_SORT_MAP["start-date-asc"],
+        ...pagination
+      };
+      if (!useLocalFiltering) {
+        const response2 = await connpassClient.searchEvents(searchParams);
+        const formatted2 = formatEventsResponse(
+          response2,
+          UI_LIST_FORMAT_OPTIONS
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(formatted2) }],
+          structuredContent: {
+            kind: "events",
+            data: formatted2
+          }
+        };
+      }
+      const response = await connpassClient.getAllEvents(searchParams);
+      const filtered = sortEvents(
+        applyLocalFilters(response.events, params),
+        params.sort
+      );
+      const pageSize = params.pageSize ?? 20;
+      const page = params.page ?? 1;
+      const sliceStart = (page - 1) * pageSize;
+      const paged = filtered.slice(sliceStart, sliceStart + pageSize);
+      const formatted = {
+        returned: paged.length,
+        available: filtered.length,
+        start: filtered.length === 0 ? 0 : sliceStart + 1,
+        events: paged.map(
+          (event) => formatEvent(event, UI_LIST_FORMAT_OPTIONS)
+        )
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(formatted) }],
+        structuredContent: {
+          kind: "events",
+          data: formatted
+        }
+      };
+    }
+  );
+}
+
+// src/tools/ui-tools/index.ts
+function registerUITools(deps) {
+  registerUIEventDetailTool(deps);
+  registerUISearchTool(deps);
+  registerUIScheduleTool(deps);
+}
+
+// src/tools/users.ts
+import { z as z8 } from "zod";
+var UserSearchInputSchema = z8.object({
+  nickname: z8.string().min(1).describe("Match users by nickname (substring search)").optional(),
+  userIds: z8.array(z8.number()).describe("Limit to specific user IDs").optional(),
+  page: z8.number().int().min(1).describe("1-based page number").optional(),
+  pageSize: z8.number().int().min(1).max(100).describe("Users per page (default 20)").optional(),
+  sort: z8.enum(USER_SORT_KEYS).describe("Ranking by activity, followers, or recency").optional()
+});
+var UserGroupsInputSchema = z8.object({
+  userId: z8.number().int().positive().describe("Connpass user ID"),
+  limit: z8.number().int().min(1).max(100).describe("How many to return (default 20)").optional(),
+  page: z8.number().int().min(1).describe("1-based page number").optional()
+});
+var UserRelationshipInputSchema = z8.object({
+  userId: z8.number().int().positive().describe("Connpass user ID"),
+  limit: z8.number().int().min(1).max(100).describe("How many to return (default 20)").optional(),
+  page: z8.number().int().min(1).describe("1-based page number").optional(),
+  sort: z8.enum(EVENT_SORT_KEYS).describe("Sort events by schedule or recency").optional(),
+  includeDetails: z8.boolean().describe(
+    "Include event description (up to 200 chars). Use when you need content details for recommendations."
+  ).default(false).optional()
 });
+function buildUserRelationshipParams(input) {
+  const pagination = applyPagination(input.page, input.limit, {
+    includePagination: true
+  });
+  return {
+    pagination,
+    order: input.sort ? EVENT_SORT_MAP[input.sort] : void 0
+  };
+}
+function registerUserTools(deps) {
+  const { server: server2, connpassClient } = deps;
+  registerAppToolIfEnabled(
+    server2,
+    "search_users",
+    {
+      title: "Search Users",
+      description: "Discover Connpass users",
+      inputSchema: UserSearchInputSchema
+    },
+    async (args) => {
+      const params = UserSearchInputSchema.parse(args ?? {});
+      const pagination = applyPagination(params.page, params.pageSize);
+      const response = await connpassClient.searchUsers({
+        nickname: params.nickname,
+        userId: params.userIds,
+        order: params.sort ? USER_SORT_MAP[params.sort] : void 0,
+        ...pagination
+      });
+      return {
+        content: [
+          { type: "text", text: summarizeUsersResponse(response) }
+        ]
+      };
+    }
+  );
+  registerAppToolIfEnabled(
+    server2,
+    "get_user_groups",
+    {
+      title: "Get User Groups",
+      description: "List the groups a user belongs to",
+      inputSchema: UserGroupsInputSchema
+    },
+    async (args) => {
+      const { userId, limit, page } = UserGroupsInputSchema.parse(args ?? {});
+      const pagination = applyPagination(page, limit);
+      const response = await connpassClient.getUserGroups(userId, pagination);
+      return {
+        content: [
+          { type: "text", text: summarizeGroupsResponse(response) }
+        ]
+      };
+    }
+  );
+  registerAppToolIfEnabled(
+    server2,
+    "get_user_attended_events",
+    {
+      title: "Get User Attended Events",
+      description: "List events that a user has attended",
+      inputSchema: UserRelationshipInputSchema
+    },
+    async (args) => {
+      const parsed = UserRelationshipInputSchema.parse(args ?? {});
+      const { pagination, order } = buildUserRelationshipParams(parsed);
+      const response = await connpassClient.getUserAttendedEvents(
+        parsed.userId,
+        { ...pagination, order }
+      );
+      const formatOptions = parsed.includeDetails ? FORMAT_PRESETS.detailed : FORMAT_PRESETS.default;
+      const formatted = formatEventsResponse(response, formatOptions);
+      return {
+        content: [
+          {
+            type: "text",
+            text: summarizeEventsResponse(formatted, "attended events")
+          }
+        ]
+      };
+    }
+  );
+  registerAppToolIfEnabled(
+    server2,
+    "get_user_presenter_events",
+    {
+      title: "Get User Presenter Events",
+      description: "List events where the user presented",
+      inputSchema: UserRelationshipInputSchema
+    },
+    async (args) => {
+      const parsed = UserRelationshipInputSchema.parse(args ?? {});
+      const { pagination, order } = buildUserRelationshipParams(parsed);
+      const response = await connpassClient.getUserPresenterEvents(
+        parsed.userId,
+        { ...pagination, order }
+      );
+      const formatOptions = parsed.includeDetails ? FORMAT_PRESETS.detailed : FORMAT_PRESETS.default;
+      const formatted = formatEventsResponse(response, formatOptions);
+      return {
+        content: [
+          {
+            type: "text",
+            text: summarizeEventsResponse(formatted, "presenter events")
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(deps) {
+  registerConnpassResource(deps);
+  registerEventTools(deps);
+  registerScheduleTools(deps);
+  registerGroupTools(deps);
+  registerPrefectureTools(deps);
+  registerUserTools(deps);
+  registerUITools(deps);
+}
+
+// src/tools/utils/searchSessionStore.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var SearchSessionStore = class {
+  ttlMs;
+  sessions = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.ttlMs = options.ttlMs ?? 10 * 60 * 1e3;
+  }
+  save(result) {
+    this.cleanup();
+    const sessionId = randomUUID2();
+    this.sessions.set(sessionId, {
+      expiresAt: Date.now() + this.ttlMs,
+      result
+    });
+    return sessionId;
+  }
+  get(sessionId) {
+    this.cleanup();
+    const entry = this.sessions.get(sessionId);
+    if (!entry) {
+      return void 0;
+    }
+    if (entry.expiresAt <= Date.now()) {
+      this.sessions.delete(sessionId);
+      return void 0;
+    }
+    return entry.result;
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [sessionId, entry] of this.sessions.entries()) {
+      if (entry.expiresAt <= now) {
+        this.sessions.delete(sessionId);
+      }
+    }
+  }
+};
+
+// src/server.ts
+var config = getConfig();
+var cachedServer = null;
+function createUnavailableConnpassClient() {
+  const message = "CONNPASS_API_KEY is required to use Connpass API tools. Set the environment variable or pass --connpass-api-key.";
+  return new Proxy({}, {
+    get(_target, property) {
+      if (property === "then") {
+        return void 0;
+      }
+      if (typeof property === "symbol") {
+        return void 0;
+      }
+      return async () => {
+        throw new Error(message);
+      };
+    }
+  });
+}
+function createConnpassClient() {
+  if (!config.connpassApiKey?.trim()) {
+    return createUnavailableConnpassClient();
+  }
+  return new ConnpassClient({
+    apiKey: config.connpassApiKey,
+    rateLimitEnabled: config.rateLimitEnabled,
+    rateLimitDelay: config.rateLimitDelayMs
+  });
+}
+function createServer() {
+  const server2 = new McpServer({
+    name: "connpass-mcp-server",
+    version: "0.3.0",
+    description: "Connpass event search and browsing MCP server with Apps UI"
+  });
+  const connpassClient = createConnpassClient();
+  const searchSessionStore = new SearchSessionStore();
+  const deps = {
+    server: server2,
+    connpassClient,
+    config,
+    searchSessionStore
+  };
+  registerAllTools(deps);
+  return server2;
+}
+function getServer() {
+  if (!cachedServer) {
+    cachedServer = createServer();
+  }
+  return cachedServer;
+}
+var server = getServer();
+
+// src/index.ts
+function isCLI() {
+  if (!isNodejs() || !process.argv) return false;
+  const isNpmStart = process.env?.npm_lifecycle_event === "start";
+  const argv1 = process.argv[1] || "";
+  const isDirectExecution = argv1.includes("connpass-mcp-apps") || argv1.endsWith("dist/index.js") || argv1.endsWith("src/index.ts") || argv1.includes("index.js") || argv1.includes("npx");
+  const config2 = getConfig();
+  const isForceMode = config2.httpMode;
+  const isMainModule = process.argv0?.includes("node") || process.argv0?.includes("bun");
+  return isNpmStart || isDirectExecution || isForceMode || isMainModule;
+}
+function printHelp() {
+  console.log(`
+${getHelpText()}`);
+}
+async function startMCPServer() {
+  if (!isNodejs()) {
+    throw new Error("Node.js environment required");
+  }
+  if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    printHelp();
+    process.exit(0);
+  }
+  const shouldStart = isCLI();
+  const config2 = getConfig();
+  if (config2.httpMode) {
+    console.error("Server configuration:", {
+      port: config2.httpPort,
+      host: config2.httpHost,
+      isDevelopment: process.env.NODE_ENV === "development",
+      isHttpMode: config2.httpMode
+    });
+  }
+  if (!shouldStart) {
+    return;
+  }
+  await launchServer({
+    server: getServer(),
+    config: config2,
+    serverName: "Connpass MCP Apps",
+    serverFactory: createServer
+  });
+}
+if (isNodejs()) {
+  startMCPServer().catch((error) => {
+    console.error("Initialization error:", error);
+  });
+}
 //# sourceMappingURL=index.js.map