@kajidog/connpass-mcp-server 0.3.0 → 0.4.1

package/dist/stdio.js

@@ -0,0 +1,2140 @@
+#!/usr/bin/env node
+
+// ../../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 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/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/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 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 _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 } = 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] = raw[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/router/reg-exp-router/node.js
+var regExpMetaChars = new Set(".\\+*[^]$()");
+
+// ../../packages/mcp-core/dist/stdio.js
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function connectStdio(server2) {
+  await server2.connect(new StdioServerTransport());
+}
+
+// src/server.ts
+import { ConnpassClient } from "@kajidog/connpass-api-client";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// 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;
+}
+
+// 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 { accepted, waiting, limit } = event.participants;
+  const capacityParts = [`${accepted}\u4EBA\u53C2\u52A0`];
+  if (waiting > 0) capacityParts.push(`\u5F85\u3061${waiting}`);
+  if (typeof limit === "number") capacityParts.push(`\u5B9A\u54E1${limit}`);
+  const capacity = capacityParts.join("/");
+  const fragments = [
+    `[id:${event.id}]`,
+    date,
+    event.title,
+    place ? `@ ${place}` : void 0,
+    `(${capacity})`
+  ].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 summarizeEventBlock(event) {
+  const headline = summarizeEventLine(event);
+  const extras = [];
+  if (event.catchPhrase) extras.push(`  ${event.catchPhrase}`);
+  if (event.group?.title) extras.push(`  group: ${event.group.title}`);
+  if (extras.length === 0) return headline;
+  return [headline, ...extras].join("\n");
+}
+function summarizeEventsResponse(response, label = "events", options) {
+  const lines = [
+    `${label}: ${response.returned} returned / ${response.available} available`
+  ];
+  if (options?.searchSessionId) {
+    lines.push(`searchSessionId: ${options.searchSessionId}`);
+  }
+  lines.push(...response.events.map(summarizeEventBlock));
+  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, "events", {
+            searchSessionId
+          })
+        }
+      ],
+      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: `Displayed ${formatted.events.length} of ${formatted.available} events in the browser UI.`
+          }
+        ],
+        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/stdio.ts
+connectStdio(getServer()).catch(() => {
+  process.exit(1);
+});
+//# sourceMappingURL=stdio.js.map