@imboard.ai/mcp-server 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1866 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/index.ts
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/config.ts
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+function loadConfig() {
+  const errors = [];
+  const apiBaseUrl = process.env.IMBOARD_API_BASE_URL?.trim();
+  const apiToken = process.env.IMBOARD_API_TOKEN?.trim();
+  if (!apiBaseUrl) {
+    errors.push("IMBOARD_API_BASE_URL is required");
+  }
+  if (!apiToken) {
+    errors.push("IMBOARD_API_TOKEN is required");
+  }
+  if (apiBaseUrl && !isValidUrl(apiBaseUrl)) {
+    errors.push(`IMBOARD_API_BASE_URL is not a valid URL: ${apiBaseUrl}`);
+  }
+  if (apiBaseUrl && isValidUrl(apiBaseUrl) && isPrivateAddress(apiBaseUrl)) {
+    errors.push("IMBOARD_API_BASE_URL must not point to a private/internal address");
+  }
+  if (errors.length > 0) {
+    throw new ConfigError(
+      `Configuration errors:
+  - ${errors.join("\n  - ")}`
+    );
+  }
+  return {
+    apiBaseUrl,
+    apiToken
+  };
+}
+function isValidUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+var PRIVATE_HOSTNAMES = ["localhost", "127.0.0.1", "0.0.0.0", "169.254.169.254", "[::1]"];
+var PRIVATE_IP_PATTERN = /^(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.)/;
+function isPrivateAddress(value) {
+  const { hostname } = new URL(value);
+  return PRIVATE_HOSTNAMES.includes(hostname) || PRIVATE_IP_PATTERN.test(hostname);
+}
+
+// src/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+
+// src/utils/redact.ts
+var TOKEN_PATTERN = /\b([a-zA-Z0-9_-]{8})[a-zA-Z0-9_-]{24,}\b/g;
+var BEARER_PATTERN = /(Bearer\s+)[a-zA-Z0-9_.\-/+=]{8,}/gi;
+function redact(value) {
+  return value.replace(BEARER_PATTERN, "$1[REDACTED]").replace(TOKEN_PATTERN, "$1***");
+}
+
+// src/utils/logging.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var minLevel = "info";
+function setLogLevel(level) {
+  minLevel = level;
+}
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
+}
+function formatMessage(level, message, context) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const redacted = redact(message);
+  const parts = [`[${timestamp}] [${level.toUpperCase()}] ${redacted}`];
+  if (context && Object.keys(context).length > 0) {
+    const safeContext = redact(JSON.stringify(context));
+    parts.push(safeContext);
+  }
+  return parts.join(" ");
+}
+var logger = {
+  debug(message, context) {
+    if (shouldLog("debug")) {
+      process.stderr.write(formatMessage("debug", message, context) + "\n");
+    }
+  },
+  info(message, context) {
+    if (shouldLog("info")) {
+      process.stderr.write(formatMessage("info", message, context) + "\n");
+    }
+  },
+  warn(message, context) {
+    if (shouldLog("warn")) {
+      process.stderr.write(formatMessage("warn", message, context) + "\n");
+    }
+  },
+  error(message, context) {
+    if (shouldLog("error")) {
+      process.stderr.write(formatMessage("error", message, context) + "\n");
+    }
+  }
+};
+
+// src/api-client/errors.ts
+var ImboardApiError = class extends Error {
+  code;
+  status;
+  requestId;
+  details;
+  constructor(payload) {
+    super(payload.message);
+    this.name = "ImboardApiError";
+    this.code = payload.code;
+    this.status = payload.status;
+    this.requestId = payload.requestId;
+    this.details = payload.details;
+  }
+};
+var ImboardApiTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`);
+    this.name = "ImboardApiTimeoutError";
+  }
+};
+var ImboardApiNetworkError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ImboardApiNetworkError";
+  }
+};
+
+// src/api-client/imboardApiClient.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_RETRIES = 2;
+var RETRY_BASE_MS = 500;
+var ImboardApiClient = class {
+  baseUrl;
+  token;
+  timeoutMs;
+  constructor(config, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    this.baseUrl = config.apiBaseUrl.replace(/\/+$/, "");
+    this.token = config.apiToken;
+    this.timeoutMs = timeoutMs;
+  }
+  async get(path, params) {
+    return this.request("GET", path, void 0, params);
+  }
+  async getCollection(path, params) {
+    return this.requestCollection("GET", path, params);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+  async request(method, path, body, params) {
+    const response = await this.executeWithRetry(method, path, body, params);
+    const requestId = response.headers.get("x-request-id");
+    const json = await response.json();
+    if (!json || typeof json !== "object" || !("data" in json)) {
+      throw new ImboardApiError({
+        code: "INTERNAL_ERROR",
+        message: 'Response body missing "data" field',
+        status: response.status,
+        requestId,
+        details: null
+      });
+    }
+    return {
+      data: json.data,
+      requestId
+    };
+  }
+  async requestCollection(method, path, params) {
+    const response = await this.executeWithRetry(method, path, void 0, params);
+    const requestId = response.headers.get("x-request-id");
+    const json = await response.json();
+    if (!json || typeof json !== "object" || !("data" in json) || !("meta" in json)) {
+      throw new ImboardApiError({
+        code: "INTERNAL_ERROR",
+        message: 'Response body missing "data" or "meta" field',
+        status: response.status,
+        requestId,
+        details: null
+      });
+    }
+    return {
+      data: json.data,
+      meta: json.meta,
+      requestId
+    };
+  }
+  async executeWithRetry(method, path, body, params) {
+    const url = this.buildUrl(path, params);
+    const isIdempotent = method === "GET";
+    const maxAttempts = isIdempotent ? MAX_RETRIES + 1 : 1;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (attempt > 0) {
+        const delayMs = RETRY_BASE_MS * Math.pow(2, attempt - 1);
+        logger.info(`Retrying ${method} ${path} (attempt ${attempt + 1}/${maxAttempts})`, { delayMs });
+        await sleep(delayMs);
+      }
+      try {
+        const response = await this.executeSingle(method, url, body);
+        if (response.ok) {
+          return response;
+        }
+        const errorBody = await this.tryParseErrorBody(response);
+        const requestId = response.headers.get("x-request-id");
+        const apiError = new ImboardApiError({
+          code: errorBody?.code ?? "INTERNAL_ERROR",
+          message: errorBody?.message ?? `HTTP ${response.status}`,
+          status: response.status,
+          requestId,
+          details: errorBody?.details ?? null
+        });
+        if (isIdempotent && response.status >= 500 && attempt < maxAttempts - 1) {
+          logger.warn(`Server error ${response.status} on ${method} ${path}, will retry`, { requestId });
+          lastError = apiError;
+          continue;
+        }
+        throw apiError;
+      } catch (error) {
+        if (error instanceof ImboardApiError) {
+          throw error;
+        }
+        if (error instanceof ImboardApiTimeoutError || error instanceof ImboardApiNetworkError) {
+          if (isIdempotent && attempt < maxAttempts - 1) {
+            lastError = error;
+            continue;
+          }
+          throw error;
+        }
+        throw new ImboardApiNetworkError(
+          error instanceof Error ? error.message : "Unknown network error"
+        );
+      }
+    }
+    throw lastError ?? new ImboardApiNetworkError("All retries exhausted");
+  }
+  async executeSingle(method, url, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    const headers = {
+      "Authorization": `Bearer ${this.token}`,
+      "Accept": "application/json"
+    };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      return response;
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new ImboardApiTimeoutError(this.timeoutMs);
+      }
+      throw new ImboardApiNetworkError(
+        error instanceof Error ? error.message : "Network request failed"
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  buildUrl(path, params) {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(`${this.baseUrl}${normalizedPath}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return url.toString();
+  }
+  async tryParseErrorBody(response) {
+    try {
+      const text = await response.text();
+      const json = JSON.parse(text);
+      return json.error;
+    } catch {
+      return void 0;
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/tools/shared.ts
+var import_zod = require("zod");
+var objectIdSchema = import_zod.z.string().regex(/^[a-f0-9]{24}$/, "Must be a 24-character hex ID");
+var boardIdParam = objectIdSchema.describe("The board ID");
+var resourceIdParam = objectIdSchema;
+var paginationParams = {
+  limit: import_zod.z.number().int().min(1).max(100).optional().describe("Number of results per page (1-100, default 25)"),
+  cursor: import_zod.z.string().optional().describe("Pagination cursor from a previous response"),
+  sort: import_zod.z.enum(["updatedAt"]).optional().describe("Sort field (default: updatedAt)"),
+  order: import_zod.z.enum(["asc", "desc"]).optional().describe("Sort order (default: desc)")
+};
+function buildQueryParams(args, filterKeys) {
+  const params = {};
+  for (const key of ["limit", "cursor", "sort", "order", ...filterKeys]) {
+    const value = args[key];
+    if (value !== void 0 && value !== null) {
+      params[key] = String(value);
+    }
+  }
+  return params;
+}
+function formatResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function errorResult(code, message, extra) {
+  const payload = { error: code, message, ...extra };
+  return {
+    isError: true,
+    content: [{ type: "text", text: JSON.stringify(payload) }]
+  };
+}
+function handleToolError(error) {
+  if (error instanceof ImboardApiError) {
+    logger.warn(`API error: ${error.code} ${error.status}`, { requestId: error.requestId });
+    const message = error.status >= 500 ? "Internal server error" : error.message;
+    const extra = { status: error.status };
+    if (error.requestId) extra.requestId = error.requestId;
+    if (error.details !== void 0 && error.details !== null) extra.details = error.details;
+    return errorResult(error.code, message, extra);
+  }
+  if (error instanceof ImboardApiTimeoutError) {
+    logger.warn(`API timeout: ${error.message}`);
+    return errorResult("TIMEOUT", error.message);
+  }
+  if (error instanceof ImboardApiNetworkError) {
+    logger.warn(`Network error: ${error.message}`);
+    return errorResult("NETWORK_ERROR", error.message);
+  }
+  logger.error("Unexpected tool error", {
+    error: error instanceof Error ? error.message : String(error),
+    stack: error instanceof Error ? error.stack : void 0
+  });
+  return errorResult("INTERNAL_ERROR", "An unexpected error occurred");
+}
+
+// src/tools/getMe.tool.ts
+var registerGetMeTool = (server, client) => {
+  server.tool(
+    "get_me",
+    "Returns the currently authenticated imboard user's profile including name, email, and timezone.",
+    {},
+    async () => {
+      try {
+        const response = await client.get("/api/me");
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/boards.tools.ts
+var import_zod2 = require("zod");
+var registerBoardsTools = (server, client) => {
+  server.tool(
+    "list_boards",
+    "Lists all boards the authenticated user has access to. Returns board name, billing state, and the user's role on each board.",
+    {
+      ...paginationParams,
+      sort: import_zod2.z.enum(["updatedAt", "createdAt"]).optional().describe("Sort field (default: updatedAt)")
+    },
+    async ({ ...rest }) => {
+      try {
+        const params = buildQueryParams(rest, []);
+        const response = await client.getCollection("/api/boards", params);
+        return formatResult({ data: response.data, meta: response.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_board",
+    "Returns details for a specific board including name, description, billing state, and the authenticated user's role.",
+    {
+      boardId: boardIdParam
+    },
+    async ({ boardId }) => {
+      try {
+        const response = await client.get(`/api/boards/${boardId}`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_board",
+    "Creates a new board. Returns the created board details.",
+    {
+      name: import_zod2.z.string().describe("Board name"),
+      description: import_zod2.z.string().optional().describe("Board description (BlockNote JSON or plain text)")
+    },
+    async ({ name, description }) => {
+      try {
+        const body = { name };
+        if (description !== void 0) body.description = description;
+        const response = await client.post("/api/board", body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_board",
+    "Updates board details (name, description, settings). Requires admin access.",
+    {
+      boardId: boardIdParam,
+      name: import_zod2.z.string().describe("Board name"),
+      description: import_zod2.z.string().optional().describe("Board description (BlockNote JSON or plain text)"),
+      companyType: import_zod2.z.string().optional().describe("Company type"),
+      boardType: import_zod2.z.string().optional().describe("Board type"),
+      companyWebsiteUrl: import_zod2.z.string().optional().describe("Company website URL (must include protocol)"),
+      defaultTimezone: import_zod2.z.string().optional().describe("Default timezone (IANA format)")
+    },
+    async ({ boardId, name, description, companyType, boardType, companyWebsiteUrl, defaultTimezone }) => {
+      try {
+        const body = { name };
+        if (description !== void 0) body.description = description;
+        if (companyType !== void 0) body.companyType = companyType;
+        if (boardType !== void 0) body.boardType = boardType;
+        if (companyWebsiteUrl !== void 0) body.companyWebsiteUrl = companyWebsiteUrl;
+        if (defaultTimezone !== void 0) body.defaultTimezone = defaultTimezone;
+        const response = await client.put(`/api/board/${boardId}`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "assign_member_roles",
+    "Assigns roles, positions, and access types to a board member.",
+    {
+      boardId: boardIdParam,
+      userId: resourceIdParam.describe("The user ID of the board member"),
+      set_admin_role: import_zod2.z.enum(["admin", "guest"]).optional().describe("Admin role to assign"),
+      set_access_type: import_zod2.z.enum(["collaborator", "viewer"]).optional().describe("Access type to assign"),
+      board_position: import_zod2.z.array(import_zod2.z.string()).optional().describe("Board positions to assign"),
+      appointingParty: import_zod2.z.string().optional().describe("Name of the appointing party")
+    },
+    async ({ boardId, userId, ...fields }) => {
+      try {
+        const body = {};
+        if (fields.set_admin_role !== void 0) body.set_admin_role = fields.set_admin_role;
+        if (fields.set_access_type !== void 0) body.set_access_type = fields.set_access_type;
+        if (fields.board_position !== void 0) body.board_position = fields.board_position;
+        if (fields.appointingParty !== void 0) body.appointingParty = fields.appointingParty;
+        const response = await client.put(`/api/board/${boardId}/members/${userId}/roles`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "search_board_documents",
+    "Semantic search across all documents in a board. Returns matching document snippets ranked by relevance.",
+    {
+      boardId: boardIdParam,
+      query: import_zod2.z.string().describe("Search query (max 1000 characters)"),
+      limit: import_zod2.z.number().int().min(1).max(50).optional().describe("Max results (1-50, default 10)"),
+      minScore: import_zod2.z.number().min(0).max(1).optional().describe("Minimum relevance score (0-1)")
+    },
+    async ({ boardId, query, limit, minScore }) => {
+      try {
+        const body = { query };
+        if (limit !== void 0) body.limit = limit;
+        if (minScore !== void 0) body.minScore = minScore;
+        const response = await client.post(`/api/board/${boardId}/search`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "list_board_action_items",
+    "Lists action items for a board. Returns open/in-progress items by default.",
+    {
+      boardId: boardIdParam,
+      includeCompleted: import_zod2.z.enum(["true", "false"]).optional().describe("Include completed items (default: false)"),
+      status: import_zod2.z.string().optional().describe("Filter by status (open, in_progress, completed, cancelled)")
+    },
+    async ({ boardId, includeCompleted, status }) => {
+      try {
+        const params = {};
+        if (includeCompleted !== void 0) params.includeCompleted = includeCompleted;
+        if (status !== void 0) params.status = status;
+        const response = await client.get(`/api/board/${boardId}/action-items`, params);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_board_action_item",
+    "Updates an action item status (in_progress, completed, cancelled).",
+    {
+      boardId: boardIdParam,
+      actionItemId: resourceIdParam.describe("The action item ID"),
+      status: import_zod2.z.string().describe("New status (open, in_progress, completed, cancelled)")
+    },
+    async ({ boardId, actionItemId, status }) => {
+      try {
+        const response = await client.patch(`/api/board/${boardId}/action-items/${actionItemId}`, { status });
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/members.tools.ts
+var registerMemberTools = (server, client) => {
+  server.tool(
+    "list_board_members",
+    "Lists members of a board including their roles, access types, and board positions.",
+    {
+      boardId: boardIdParam,
+      ...paginationParams
+    },
+    async ({ boardId, ...rest }) => {
+      try {
+        const params = buildQueryParams(rest, []);
+        const result = await client.getCollection(
+          `/api/boards/${boardId}/members`,
+          params
+        );
+        return formatResult({ data: result.data, meta: result.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_board_member",
+    "Returns details for a specific board member including their role, access type, and board positions.",
+    {
+      boardId: boardIdParam,
+      memberId: resourceIdParam.describe("The member ID")
+    },
+    async ({ boardId, memberId }) => {
+      try {
+        const result = await client.get(
+          `/api/boards/${boardId}/members/${memberId}`
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/meetings.tools.ts
+var import_zod3 = require("zod");
+var registerMeetingTools = (server, client) => {
+  server.tool(
+    "list_board_meetings",
+    "Lists meetings for a board. Supports filtering by status and date range, and sorting by start time.",
+    {
+      boardId: boardIdParam,
+      ...paginationParams,
+      sort: import_zod3.z.enum(["updatedAt", "startTime"]).optional().describe("Sort field (default: startTime)"),
+      status: import_zod3.z.string().optional().describe("Filter by meeting status"),
+      startAfter: import_zod3.z.string().optional().describe("ISO-8601 date \u2014 only meetings starting after this"),
+      startBefore: import_zod3.z.string().optional().describe("ISO-8601 date \u2014 only meetings starting before this")
+    },
+    async ({ boardId, ...rest }) => {
+      try {
+        const params = buildQueryParams(rest, ["status", "startAfter", "startBefore"]);
+        const result = await client.getCollection(
+          `/api/boards/${boardId}/meetings`,
+          params
+        );
+        return formatResult({ data: result.data, meta: result.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_meeting",
+    "Returns details for a specific meeting including title, status, location, and scheduled time.",
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe("The meeting ID")
+    },
+    async ({ boardId, meetingId }) => {
+      try {
+        const result = await client.get(
+          `/api/boards/${boardId}/meetings/${meetingId}`
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_meeting",
+    "Creates a new meeting on a board. Requires write access. The authenticated user is set as the creator.",
+    {
+      boardId: boardIdParam,
+      title: import_zod3.z.string().describe("Meeting title (max 200 characters)"),
+      status: import_zod3.z.string().describe("Meeting status: draft, planned, scheduled, completed, or finalized"),
+      locationType: import_zod3.z.string().describe("Location type: physical, virtual, or hybrid"),
+      startTime: import_zod3.z.string().describe("Meeting start time as ISO-8601 date string"),
+      endTime: import_zod3.z.string().describe("Meeting end time as ISO-8601 date string"),
+      location: import_zod3.z.string().optional().describe("Physical location (max 255 characters)"),
+      virtualMeetingUrl: import_zod3.z.string().optional().describe("Virtual meeting URL (max 255 characters)")
+    },
+    async ({ boardId, title, status, locationType, startTime, endTime, location, virtualMeetingUrl }) => {
+      try {
+        const body = {
+          title,
+          status,
+          locationType,
+          startTime,
+          endTime
+        };
+        if (location !== void 0) body.location = location;
+        if (virtualMeetingUrl !== void 0) body.virtualMeetingUrl = virtualMeetingUrl;
+        const result = await client.post(
+          `/api/boards/${boardId}/meetings`,
+          body
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_meeting",
+    "Updates an existing meeting. Only the provided fields are changed. Requires write access to the board.",
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe("The meeting ID"),
+      title: import_zod3.z.string().optional().describe("Meeting title (max 200 characters)"),
+      status: import_zod3.z.string().optional().describe("Meeting status: draft, planned, scheduled, completed, or finalized"),
+      locationType: import_zod3.z.string().optional().describe("Location type: physical, virtual, or hybrid"),
+      location: import_zod3.z.string().optional().describe("Physical location (max 255 characters)"),
+      virtualMeetingUrl: import_zod3.z.string().optional().describe("Virtual meeting URL (max 255 characters)"),
+      startTime: import_zod3.z.string().optional().describe("Meeting start time as ISO-8601 date string"),
+      endTime: import_zod3.z.string().optional().describe("Meeting end time as ISO-8601 date string")
+    },
+    async ({ boardId, meetingId, title, status, locationType, location, virtualMeetingUrl, startTime, endTime }) => {
+      try {
+        const body = {};
+        if (title !== void 0) body.title = title;
+        if (status !== void 0) body.status = status;
+        if (locationType !== void 0) body.locationType = locationType;
+        if (location !== void 0) body.location = location;
+        if (virtualMeetingUrl !== void 0) body.virtualMeetingUrl = virtualMeetingUrl;
+        if (startTime !== void 0) body.startTime = startTime;
+        if (endTime !== void 0) body.endTime = endTime;
+        const result = await client.patch(
+          `/api/boards/${boardId}/meetings/${meetingId}`,
+          body
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_meeting",
+    "Deletes a meeting from a board.",
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe("The meeting ID")
+    },
+    async ({ boardId, meetingId }) => {
+      try {
+        const result = await client.delete(
+          `/api/meetings/${boardId}/${meetingId}/`
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "change_meeting_status",
+    "Changes meeting status (draft, planned, scheduled, completed, finalized).",
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe("The meeting ID"),
+      meetingStatus: import_zod3.z.string().describe("New meeting status: draft, planned, scheduled, completed, or finalized")
+    },
+    async ({ boardId, meetingId, meetingStatus }) => {
+      try {
+        const result = await client.put(
+          `/api/meetings/${boardId}/${meetingId}/status`,
+          { meetingStatus }
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/documents.tools.ts
+var import_zod4 = require("zod");
+var registerDocumentTools = (server, client) => {
+  server.tool(
+    "list_board_documents",
+    "Lists document metadata for a board. Supports filtering by meeting or document type. Does not provide file download in V1.",
+    {
+      boardId: boardIdParam,
+      ...paginationParams,
+      meetingId: import_zod4.z.string().optional().describe("Filter by meeting ID"),
+      documentType: import_zod4.z.string().optional().describe("Filter by document type (e.g. boardResolutions, minutesOfMeetings, capTable)")
+    },
+    async ({ boardId, ...rest }) => {
+      try {
+        const params = buildQueryParams(rest, ["meetingId", "documentType"]);
+        const result = await client.getCollection(
+          `/api/boards/${boardId}/documents`,
+          params
+        );
+        return formatResult({ data: result.data, meta: result.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_document",
+    "Returns metadata for a specific document including title, type, and associated meeting. Does not provide file download in V1.",
+    {
+      boardId: boardIdParam,
+      documentId: resourceIdParam.describe("The document ID")
+    },
+    async ({ boardId, documentId }) => {
+      try {
+        const result = await client.get(
+          `/api/boards/${boardId}/documents/${documentId}`
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/documents-write.tools.ts
+var import_zod5 = require("zod");
+var registerDocumentWriteTools = (server, client) => {
+  server.tool(
+    "create_document",
+    "Creates a new document with an initial version. Requires a title and optionally a document type and external file link.",
+    {
+      boardId: boardIdParam,
+      title: import_zod5.z.string().describe("Document title"),
+      documentType: import_zod5.z.string().optional().describe("Document type (e.g. boardResolutions, minutesOfMeetings, capTable)"),
+      externalFileLink: import_zod5.z.string().optional().describe("HTTPS URL to an external file"),
+      meetingIds: import_zod5.z.array(import_zod5.z.string()).optional().describe("Array of meeting IDs to associate with")
+    },
+    async ({ boardId, title, documentType, externalFileLink, meetingIds }) => {
+      try {
+        const body = { title };
+        if (documentType !== void 0) body.documentType = documentType;
+        if (externalFileLink !== void 0) body.externalFileLink = externalFileLink;
+        if (meetingIds !== void 0) body.meetingIds = meetingIds;
+        const response = await client.post(`/api/documents/${boardId}/`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_document",
+    "Updates document details (title, meeting associations, working copy link).",
+    {
+      boardId: boardIdParam,
+      documentId: resourceIdParam.describe("The document ID"),
+      title: import_zod5.z.string().optional().describe("New document title"),
+      documentType: import_zod5.z.string().optional().describe("Document type"),
+      workingCopyLink: import_zod5.z.string().optional().describe("URL to working copy"),
+      meetingIds: import_zod5.z.array(import_zod5.z.string()).optional().describe("Array of meeting IDs to associate with")
+    },
+    async ({ boardId, documentId, title, documentType, workingCopyLink, meetingIds }) => {
+      try {
+        const body = {};
+        if (title !== void 0) body.title = title;
+        if (documentType !== void 0) body.documentType = documentType;
+        if (workingCopyLink !== void 0) body.workingCopyLink = workingCopyLink;
+        if (meetingIds !== void 0) body.meetingIds = meetingIds;
+        const response = await client.put(`/api/documents/${boardId}/${documentId}/`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_document_status",
+    "Changes document status (draft, review, approved, etc.).",
+    {
+      boardId: boardIdParam,
+      documentId: resourceIdParam.describe("The document ID"),
+      documentStatus: import_zod5.z.string().describe("New document status")
+    },
+    async ({ boardId, documentId, documentStatus }) => {
+      try {
+        const response = await client.put(`/api/documents/${boardId}/${documentId}/status`, { documentStatus });
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_document",
+    "Deletes a document from a board.",
+    {
+      boardId: boardIdParam,
+      documentId: resourceIdParam.describe("The document ID")
+    },
+    async ({ boardId, documentId }) => {
+      try {
+        const response = await client.delete(`/api/documents/${boardId}/${documentId}/`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_document_version",
+    "Creates a new version of a document. Requires an external file link (file upload not supported via MCP).",
+    {
+      boardId: boardIdParam,
+      documentId: resourceIdParam.describe("The document ID"),
+      externalFileLink: import_zod5.z.string().describe("HTTPS URL to the new version file"),
+      notes: import_zod5.z.string().optional().describe("Version notes")
+    },
+    async ({ boardId, documentId, externalFileLink, notes }) => {
+      try {
+        const body = { externalFileLink };
+        if (notes !== void 0) body.notes = notes;
+        const response = await client.post(`/api/documents/${boardId}/${documentId}/version`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/reports.tools.ts
+var import_zod6 = require("zod");
+var registerReportTools = (server, client) => {
+  server.tool(
+    "list_board_reports",
+    "Lists reports for a board. Supports filtering by status.",
+    {
+      boardId: boardIdParam,
+      ...paginationParams,
+      status: import_zod6.z.enum(["draft", "publishedForReview", "finalized", "archived", "ongoing"]).optional().describe("Filter by report status")
+    },
+    async ({ boardId, ...rest }) => {
+      try {
+        const params = buildQueryParams(rest, ["status"]);
+        const result = await client.getCollection(
+          `/api/boards/${boardId}/reports`,
+          params
+        );
+        return formatResult({ data: result.data, meta: result.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_report",
+    "Returns details for a specific board report including title, status, and publication date.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID")
+    },
+    async ({ boardId, reportId }) => {
+      try {
+        const result = await client.get(
+          `/api/boards/${boardId}/reports/${reportId}`
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_report",
+    "Creates a new report for a board.",
+    {
+      boardId: boardIdParam,
+      name: import_zod6.z.string().describe("Report name"),
+      description: import_zod6.z.string().optional().describe("Report description"),
+      meetingIds: import_zod6.z.array(import_zod6.z.string()).optional().describe("Meeting IDs to associate with"),
+      periodStart: import_zod6.z.string().optional().describe("Period start date (YYYY-MM-DD)"),
+      periodEnd: import_zod6.z.string().optional().describe("Period end date (YYYY-MM-DD)")
+    },
+    async ({ boardId, name, description, meetingIds, periodStart, periodEnd }) => {
+      try {
+        const body = { name };
+        if (description !== void 0) body.description = description;
+        if (meetingIds !== void 0) body.meetingIds = meetingIds;
+        if (periodStart !== void 0) body.periodStart = periodStart;
+        if (periodEnd !== void 0) body.periodEnd = periodEnd;
+        const result = await client.post(`/api/reports/${boardId}`, body);
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_report",
+    "Updates report details (name, description, status, period dates).",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      name: import_zod6.z.string().optional().describe("Report name"),
+      description: import_zod6.z.string().optional().describe("Report description"),
+      status: import_zod6.z.string().optional().describe("Report status"),
+      meetingIds: import_zod6.z.array(import_zod6.z.string()).optional().describe("Meeting IDs to associate with"),
+      periodStart: import_zod6.z.string().optional().describe("Period start date (YYYY-MM-DD)"),
+      periodEnd: import_zod6.z.string().optional().describe("Period end date (YYYY-MM-DD)")
+    },
+    async ({ boardId, reportId, name, description, status, meetingIds, periodStart, periodEnd }) => {
+      try {
+        const body = {};
+        if (name !== void 0) body.name = name;
+        if (description !== void 0) body.description = description;
+        if (status !== void 0) body.status = status;
+        if (meetingIds !== void 0) body.meetingIds = meetingIds;
+        if (periodStart !== void 0) body.periodStart = periodStart;
+        if (periodEnd !== void 0) body.periodEnd = periodEnd;
+        const result = await client.put(`/api/reports/${boardId}/${reportId}`, body);
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "promote_report_status",
+    "Promotes report status (draft -> review -> published).",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      status: import_zod6.z.string().describe("Target status (e.g. publishedForReview, finalized)")
+    },
+    async ({ boardId, reportId, status }) => {
+      try {
+        const result = await client.put(`/api/reports/${boardId}/${reportId}/promote`, { status });
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_followup_report",
+    "Creates a follow-up report from an existing report, copying dashboards and settings.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The source report ID"),
+      name: import_zod6.z.string().describe("Name for the follow-up report"),
+      description: import_zod6.z.string().optional().describe("Report description"),
+      meetingIds: import_zod6.z.array(import_zod6.z.string()).optional().describe("Meeting IDs to associate with"),
+      periodStart: import_zod6.z.string().optional().describe("Period start date (YYYY-MM-DD)"),
+      periodEnd: import_zod6.z.string().optional().describe("Period end date (YYYY-MM-DD)")
+    },
+    async ({ boardId, reportId, name, description, meetingIds, periodStart, periodEnd }) => {
+      try {
+        const body = { name };
+        if (description !== void 0) body.description = description;
+        if (meetingIds !== void 0) body.meetingIds = meetingIds;
+        if (periodStart !== void 0) body.periodStart = periodStart;
+        if (periodEnd !== void 0) body.periodEnd = periodEnd;
+        const result = await client.post(`/api/reports/${boardId}/${reportId}/followup`, body);
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_dashboard",
+    "Creates a custom dashboard in a report.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      customName: import_zod6.z.string().describe("Dashboard name (1-100 characters)"),
+      displayOrder: import_zod6.z.number().optional().describe("Display order position")
+    },
+    async ({ boardId, reportId, customName, displayOrder }) => {
+      try {
+        const body = { customName };
+        if (displayOrder !== void 0) body.displayOrder = displayOrder;
+        const result = await client.post(`/api/reports/${boardId}/${reportId}/dashboards`, body);
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_dashboard_version",
+    "Creates a new version of a dashboard with updated content.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      dashboardId: resourceIdParam.describe("The dashboard ID"),
+      content: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).describe("Dashboard content object (must include _type field)"),
+      notes: import_zod6.z.array(import_zod6.z.string()).optional().describe("Version notes")
+    },
+    async ({ boardId, reportId, dashboardId, content, notes }) => {
+      try {
+        const body = { content };
+        if (notes !== void 0) body.notes = notes;
+        const result = await client.post(
+          `/api/reports/${boardId}/${reportId}/dashboards/${dashboardId}/versions`,
+          body
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_dashboard_review_status",
+    "Updates the review status of a dashboard.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      dashboardId: resourceIdParam.describe("The dashboard ID"),
+      newStatus: import_zod6.z.string().describe("New review status")
+    },
+    async ({ boardId, reportId, dashboardId, newStatus }) => {
+      try {
+        const result = await client.put(
+          `/api/reports/${boardId}/${reportId}/dashboards/${dashboardId}/review-status`,
+          { newStatus }
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_dashboard_chat",
+    "Gets discussion comments on a dashboard.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      dashboardId: resourceIdParam.describe("The dashboard ID"),
+      chatType: import_zod6.z.enum(["internal", "boardFeedback"]).optional().describe("Chat type filter")
+    },
+    async ({ boardId, reportId, dashboardId, chatType }) => {
+      try {
+        const params = {};
+        if (chatType !== void 0) params.chatType = chatType;
+        const result = await client.get(
+          `/api/reports/${boardId}/${reportId}/dashboards/${dashboardId}/chat`,
+          params
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "post_dashboard_chat",
+    "Posts a comment on a dashboard.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      dashboardId: resourceIdParam.describe("The dashboard ID"),
+      message: import_zod6.z.string().describe("Comment text (1-5000 characters)"),
+      chatType: import_zod6.z.enum(["internal", "boardFeedback"]).describe("Chat type: internal or boardFeedback"),
+      recipientId: import_zod6.z.string().optional().describe("Recipient user ID (for directed feedback)")
+    },
+    async ({ boardId, reportId, dashboardId, message, chatType, recipientId }) => {
+      try {
+        const body = { message, chatType };
+        if (recipientId !== void 0) body.recipientId = recipientId;
+        const result = await client.post(
+          `/api/reports/${boardId}/${reportId}/dashboards/${dashboardId}/chat`,
+          body
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_board_feedback",
+    "Gets board-level feedback on a report.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      recipientId: import_zod6.z.string().optional().describe("Filter by recipient user ID")
+    },
+    async ({ boardId, reportId, recipientId }) => {
+      try {
+        const params = {};
+        if (recipientId !== void 0) params.recipientId = recipientId;
+        const result = await client.get(
+          `/api/reports/${boardId}/${reportId}/board-feedback`,
+          params
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "post_board_feedback",
+    "Posts board-level feedback on a report.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      message: import_zod6.z.string().describe("Feedback text (1-5000 characters)"),
+      recipientId: resourceIdParam.describe("Recipient user ID")
+    },
+    async ({ boardId, reportId, message, recipientId }) => {
+      try {
+        const result = await client.post(
+          `/api/reports/${boardId}/${reportId}/board-feedback`,
+          { message, recipientId }
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "trigger_report_audit",
+    "Triggers an AI audit of a report.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      includeAiAnalysis: import_zod6.z.boolean().optional().describe("Include AI analysis (default: true)")
+    },
+    async ({ boardId, reportId, includeAiAnalysis }) => {
+      try {
+        const body = {};
+        if (includeAiAnalysis !== void 0) body.includeAiAnalysis = includeAiAnalysis;
+        const result = await client.post(`/api/reports/${boardId}/${reportId}/audit`, body);
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "list_report_audits",
+    "Lists audit history for a report.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID")
+    },
+    async ({ boardId, reportId }) => {
+      try {
+        const result = await client.get(`/api/reports/${boardId}/${reportId}/audits`);
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_report_audit",
+    "Gets details of a specific report audit.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      auditId: resourceIdParam.describe("The audit ID")
+    },
+    async ({ boardId, reportId, auditId }) => {
+      try {
+        const result = await client.get(`/api/reports/${boardId}/${reportId}/audits/${auditId}`);
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_historical_metrics",
+    "Gets historical KPI data for a board. Supports filtering by period type, date range, and number of periods.",
+    {
+      boardId: boardIdParam,
+      periodType: import_zod6.z.enum(["monthly", "quarterly", "yearly"]).optional().describe("Period type (default: monthly)"),
+      periods: import_zod6.z.number().int().min(1).max(48).optional().describe("Number of periods (1-48)"),
+      startDate: import_zod6.z.string().optional().describe("Start date (ISO 8601)"),
+      endDate: import_zod6.z.string().optional().describe("End date (ISO 8601)"),
+      includeDerived: import_zod6.z.boolean().optional().describe("Include derived metrics")
+    },
+    async ({ boardId, periodType, periods, startDate, endDate, includeDerived }) => {
+      try {
+        const params = {};
+        if (periodType !== void 0) params.periodType = periodType;
+        if (periods !== void 0) params.periods = String(periods);
+        if (startDate !== void 0) params.startDate = startDate;
+        if (endDate !== void 0) params.endDate = endDate;
+        if (includeDerived !== void 0) params.includeDerived = String(includeDerived);
+        const result = await client.get(`/api/boards/${boardId}/historical-metrics`, params);
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_metrics_comparison",
+    "Compares metrics across time periods for a board.",
+    {
+      boardId: boardIdParam,
+      metric: import_zod6.z.string().describe("Metric key to compare"),
+      basePeriod: import_zod6.z.string().describe("Base period (e.g. 2025-01)"),
+      comparisonPeriod: import_zod6.z.string().describe("Comparison period (e.g. 2025-02)"),
+      periodType: import_zod6.z.enum(["monthly", "quarterly", "yearly"]).optional().describe("Period type")
+    },
+    async ({ boardId, metric, basePeriod, comparisonPeriod, periodType }) => {
+      try {
+        const params = { metric, basePeriod, comparisonPeriod };
+        if (periodType !== void 0) params.periodType = periodType;
+        const result = await client.get(`/api/boards/${boardId}/metrics-comparison`, params);
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/dashboards.tools.ts
+var registerDashboardTools = (server, client) => {
+  server.tool(
+    "list_report_dashboards",
+    "Lists dashboards under a specific report. Dashboards are nested under reports in imboard's domain model.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID (required \u2014 dashboards are nested under reports)"),
+      ...paginationParams
+    },
+    async ({ boardId, reportId, ...rest }) => {
+      try {
+        const params = buildQueryParams(rest, []);
+        const result = await client.getCollection(
+          `/api/boards/${boardId}/reports/${reportId}/dashboards`,
+          params
+        );
+        return formatResult({ data: result.data, meta: result.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_dashboard",
+    "Returns details for a specific dashboard including type, title, and associated report.",
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe("The report ID"),
+      dashboardId: resourceIdParam.describe("The dashboard ID")
+    },
+    async ({ boardId, reportId, dashboardId }) => {
+      try {
+        const result = await client.get(
+          `/api/boards/${boardId}/reports/${reportId}/dashboards/${dashboardId}`
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/slots.tools.ts
+var import_zod7 = require("zod");
+var registerSlotTools = (server, client) => {
+  server.tool(
+    "list_meeting_slots",
+    "Lists proposed time slots with vote tallies for a meeting. Each slot has feedbacks showing how each member voted.",
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe("The meeting ID")
+    },
+    async ({ boardId, meetingId }) => {
+      try {
+        const result = await client.getCollection(
+          `/api/boards/${boardId}/meetings/${meetingId}/slots`
+        );
+        return formatResult({ data: result.data, meta: result.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_meeting_slot",
+    'Proposes a new time slot for a meeting. The creator is automatically marked as "ok". All other board members start as "didNotVote".',
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe("The meeting ID"),
+      startTime: import_zod7.z.string().describe('Proposed start time as ISO-8601 UTC string (e.g. "2025-07-15T14:00:00.000Z")'),
+      timezone: import_zod7.z.string().describe('IANA timezone for display (e.g. "America/New_York")'),
+      durationInMinutes: import_zod7.z.number().int().min(15).max(180).optional().describe("Duration in minutes (15-180, default 120)")
+    },
+    async ({ boardId, meetingId, startTime, timezone, durationInMinutes }) => {
+      try {
+        const body = { startTime, timezone };
+        if (durationInMinutes !== void 0) body.durationInMinutes = durationInMinutes;
+        const result = await client.post(
+          `/api/boards/${boardId}/meetings/${meetingId}/slots`,
+          body
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "vote_on_slot",
+    "Casts or updates the authenticated user's vote on a proposed meeting time slot.",
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe("The meeting ID"),
+      slotId: resourceIdParam.describe("The proposed slot ID"),
+      vote: import_zod7.z.enum(["ok", "challenging", "cant"]).describe('Vote: "ok" (can attend), "challenging" (maybe), "cant" (cannot attend)'),
+      comment: import_zod7.z.string().max(500).optional().describe("Optional comment explaining the vote")
+    },
+    async ({ boardId, meetingId, slotId, vote, comment }) => {
+      try {
+        const body = { vote };
+        if (comment !== void 0) body.comment = comment;
+        const result = await client.put(
+          `/api/boards/${boardId}/meetings/${meetingId}/slots/${slotId}/vote`,
+          body
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "delete_meeting_slot",
+    "Removes a proposed time slot from a meeting.",
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe("The meeting ID"),
+      slotId: resourceIdParam.describe("The proposed slot ID")
+    },
+    async ({ boardId, meetingId, slotId }) => {
+      try {
+        const result = await client.delete(
+          `/api/boards/${boardId}/meetings/${meetingId}/slots/${slotId}`
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "confirm_meeting_slot",
+    "Confirms a proposed slot as the meeting's scheduled time. Copies the slot's start time, duration, and timezone to the meeting.",
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe("The meeting ID"),
+      slotId: resourceIdParam.describe("The proposed slot ID to confirm")
+    },
+    async ({ boardId, meetingId, slotId }) => {
+      try {
+        const result = await client.post(
+          `/api/boards/${boardId}/meetings/${meetingId}/slots/${slotId}/confirm`
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/invites.tools.ts
+var import_zod8 = require("zod");
+var registerInviteTools = (server, client) => {
+  server.tool(
+    "list_board_invites",
+    "Lists pending invites for a board.",
+    {
+      boardId: boardIdParam
+    },
+    async ({ boardId }) => {
+      try {
+        const response = await client.get(`/api/invite/${boardId}/invites`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "create_invite",
+    "Invites a user to a board by email. Optionally include a personal message and board positions.",
+    {
+      boardId: boardIdParam,
+      inviteeEmail: import_zod8.z.string().email().describe("Email address of the person to invite"),
+      message: import_zod8.z.string().optional().describe("Optional personal message included in the invite email"),
+      boardPositions: import_zod8.z.array(import_zod8.z.string()).optional().describe("Board positions to assign to the invitee")
+    },
+    async ({ boardId, inviteeEmail, message, boardPositions }) => {
+      try {
+        const body = { inviteeEmail };
+        if (message !== void 0) body.message = message;
+        if (boardPositions !== void 0) body.boardPositions = boardPositions;
+        const response = await client.post(`/api/invite/${boardId}`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "accept_invite",
+    "Accepts a board invite.",
+    {
+      boardInviteId: resourceIdParam.describe("The invite ID")
+    },
+    async ({ boardInviteId }) => {
+      try {
+        const response = await client.put(`/api/invite/accept/${boardInviteId}`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "decline_invite",
+    "Declines a board invite.",
+    {
+      boardInviteId: resourceIdParam.describe("The invite ID")
+    },
+    async ({ boardInviteId }) => {
+      try {
+        const response = await client.put(`/api/invite/decline/${boardInviteId}`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "retract_invite",
+    "Retracts a sent board invite.",
+    {
+      boardInviteId: resourceIdParam.describe("The invite ID")
+    },
+    async ({ boardInviteId }) => {
+      try {
+        const response = await client.put(`/api/invite/retract/${boardInviteId}`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/notifications.tools.ts
+var registerNotificationTools = (server, client) => {
+  server.tool(
+    "list_notifications",
+    "Lists notifications for the authenticated user.",
+    {},
+    async () => {
+      try {
+        const response = await client.get("/api/notification/");
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "mark_all_notifications_read",
+    "Marks all notifications as read.",
+    {},
+    async () => {
+      try {
+        const response = await client.put("/api/notification/read/all");
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "mark_notification_read",
+    "Marks a single notification as read.",
+    {
+      notificationId: resourceIdParam.describe("The notification ID")
+    },
+    async ({ notificationId }) => {
+      try {
+        const response = await client.put(`/api/notification/read/${notificationId}`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/action-items.tools.ts
+var import_zod9 = require("zod");
+var registerActionItemTools = (server, client) => {
+  server.tool(
+    "list_my_action_items",
+    "Lists action items assigned to the authenticated user across all boards.",
+    {
+      includeCompleted: import_zod9.z.enum(["true", "false"]).optional().describe("Include completed items (default: false)"),
+      status: import_zod9.z.string().optional().describe("Filter by status (open, in_progress, completed, cancelled)")
+    },
+    async ({ includeCompleted, status }) => {
+      try {
+        const params = {};
+        if (includeCompleted !== void 0) params.includeCompleted = includeCompleted;
+        if (status !== void 0) params.status = status;
+        const response = await client.get("/api/action-items/my", params);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "update_action_item_status",
+    "Updates an action item status (in_progress, completed, cancelled).",
+    {
+      actionItemId: resourceIdParam.describe("The action item ID"),
+      status: import_zod9.z.string().describe("New status (open, in_progress, completed, cancelled)")
+    },
+    async ({ actionItemId, status }) => {
+      try {
+        const response = await client.patch(`/api/action-items/${actionItemId}/status`, { status });
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/user.tools.ts
+var registerUserTools = (server, client) => {
+  server.tool(
+    "list_my_boards",
+    "Lists all board memberships and pending invites for the authenticated user.",
+    {},
+    async () => {
+      try {
+        const response = await client.get("/api/user/allboards");
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_storage_usage",
+    "Returns storage usage for unassigned email attachments.",
+    {},
+    async () => {
+      try {
+        const response = await client.get("/api/user/storage");
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/tools/supporting.tools.ts
+var import_zod10 = require("zod");
+var registerSupportingTools = (server, client) => {
+  server.tool(
+    "get_board_audit_log",
+    "Gets the audit trail for a board. Returns a chronological list of actions taken on the board.",
+    {
+      boardId: boardIdParam
+    },
+    async ({ boardId }) => {
+      try {
+        const response = await client.get(`/api/auditlog/${boardId}`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_portfolio_data",
+    "Gets portfolio data aggregated across all boards. Useful for cross-board analytics.",
+    {
+      getOnlyMyPortfolio: import_zod10.z.enum(["true", "false"]).optional().describe("Only include boards where user is a member (default: false)"),
+      includeArchived: import_zod10.z.enum(["true", "false"]).optional().describe("Include archived boards (default: false)")
+    },
+    async ({ getOnlyMyPortfolio, includeArchived }) => {
+      try {
+        const params = {};
+        if (getOnlyMyPortfolio !== void 0) params.getOnlyMyPortfolio = getOnlyMyPortfolio;
+        if (includeArchived !== void 0) params.includeArchived = includeArchived;
+        const response = await client.get("/api/portfolio/data", params);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "get_fx_rates",
+    "Gets current foreign exchange rates. Optionally specify base currency, targets, and date.",
+    {
+      base: import_zod10.z.string().length(3).optional().describe("Base currency (3-letter ISO 4217 code, e.g. USD)"),
+      targets: import_zod10.z.array(import_zod10.z.string().length(3)).optional().describe("Target currencies to convert to"),
+      date: import_zod10.z.string().optional().describe("Historical date in YYYY-MM-DD format")
+    },
+    async ({ base, targets, date }) => {
+      try {
+        const params = {};
+        if (base !== void 0) params.base = base;
+        if (targets !== void 0) params["targets[]"] = targets.join(",");
+        if (date !== void 0) params.date = date;
+        const response = await client.get("/api/fx/rates", params);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "list_unassigned_attachments",
+    "Lists email attachments awaiting assignment to documents.",
+    {},
+    async () => {
+      try {
+        const response = await client.get("/api/unassigned-emails/");
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+  server.tool(
+    "reject_attachment",
+    "Rejects an unassigned email attachment.",
+    {
+      attachmentId: resourceIdParam.describe("The attachment ID")
+    },
+    async ({ attachmentId }) => {
+      try {
+        const response = await client.put(`/api/unassigned-emails/attachment/${attachmentId}`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    }
+  );
+};
+
+// src/resources/docs.resources.ts
+var DOCS_BASE_URL = "https://docs.imboard.ai";
+var STATIC_RESOURCES = [
+  {
+    uri: `${DOCS_BASE_URL}/openapi.json`,
+    name: "OpenAPI Specification",
+    description: "Complete OpenAPI 3.1 spec for the imboard REST API \u2014 all endpoints, schemas, and examples",
+    mimeType: "application/json"
+  },
+  {
+    uri: `${DOCS_BASE_URL}/llms.txt`,
+    name: "LLMs.txt Index",
+    description: "Structured index of all documentation pages \u2014 optimized for LLM consumption",
+    mimeType: "text/plain"
+  },
+  {
+    uri: `${DOCS_BASE_URL}/llms-full.txt`,
+    name: "Full Documentation (LLM)",
+    description: "Complete documentation content in a single text file \u2014 all guides, references, and examples",
+    mimeType: "text/plain"
+  },
+  {
+    uri: `${DOCS_BASE_URL}/api/schemas`,
+    name: "Schema Index",
+    description: "JSON index of all resource schemas (board, meeting, document, report, dashboard)",
+    mimeType: "application/json"
+  },
+  {
+    uri: `${DOCS_BASE_URL}/api/recipes`,
+    name: "Recipe Index",
+    description: "JSON index of available dossier recipes (financial-update, sales-pipeline-update)",
+    mimeType: "application/json"
+  }
+];
+function registerDocsResources(server) {
+  for (const resource of STATIC_RESOURCES) {
+    server.resource(resource.name, resource.uri, {
+      description: resource.description,
+      mimeType: resource.mimeType
+    }, async () => {
+      try {
+        const response = await fetch(resource.uri);
+        if (!response.ok) {
+          return {
+            contents: [
+              {
+                uri: resource.uri,
+                mimeType: "text/plain",
+                text: `Failed to fetch ${resource.uri}: ${response.status} ${response.statusText}`
+              }
+            ]
+          };
+        }
+        const text = await response.text();
+        return {
+          contents: [
+            {
+              uri: resource.uri,
+              mimeType: resource.mimeType,
+              text
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          contents: [
+            {
+              uri: resource.uri,
+              mimeType: "text/plain",
+              text: `Error fetching ${resource.uri}: ${message}`
+            }
+          ]
+        };
+      }
+    });
+  }
+  logger.info(`Registered ${STATIC_RESOURCES.length} docs resources`);
+}
+
+// src/server.ts
+var SERVER_NAME = "imboard-mcp-server";
+var SERVER_VERSION = "0.1.0";
+function createServer(config) {
+  logger.info(`Creating ${SERVER_NAME} v${SERVER_VERSION}`);
+  const server = new import_mcp.McpServer({
+    name: SERVER_NAME,
+    version: SERVER_VERSION
+  });
+  const api = new ImboardApiClient(config);
+  registerGetMeTool(server, api);
+  registerBoardsTools(server, api);
+  registerMemberTools(server, api);
+  registerMeetingTools(server, api);
+  registerDocumentTools(server, api);
+  registerDocumentWriteTools(server, api);
+  registerReportTools(server, api);
+  registerDashboardTools(server, api);
+  registerSlotTools(server, api);
+  registerInviteTools(server, api);
+  registerNotificationTools(server, api);
+  registerActionItemTools(server, api);
+  registerUserTools(server, api);
+  registerSupportingTools(server, api);
+  registerDocsResources(server);
+  logger.info("All tools and resources registered");
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  if (process.env.LOG_LEVEL) {
+    setLogLevel(process.env.LOG_LEVEL);
+  }
+  logger.info("Starting imboard MCP server...");
+  const config = loadConfig();
+  logger.info("Configuration loaded", { apiBaseUrl: config.apiBaseUrl });
+  const server = createServer(config);
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  logger.info("MCP server connected via stdio transport");
+}
+main().catch((err) => {
+  if (err instanceof ConfigError) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+  logger.error("Fatal error during startup", {
+    error: err instanceof Error ? err.message : String(err)
+  });
+  process.exit(1);
+});
+//# sourceMappingURL=index.cjs.map