@dashflow/ms365-mcp-server 1.0.0

package/dist/generated/hack.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+function makeApi(endpoints) {
+  return endpoints;
+}
+class Zodios {
+  constructor(baseUrlOrEndpoints, endpoints, options) {
+    if (typeof baseUrlOrEndpoints === "string") {
+      throw new Error("No such hack");
+    }
+    this.endpoints = baseUrlOrEndpoints.map((endpoint) => {
+      endpoint.parameters = endpoint.parameters || [];
+      for (const parameter of endpoint.parameters) {
+        parameter.name = parameter.name.replace(/[$_]+/g, "");
+      }
+      const pathParamRegex = /:([a-zA-Z0-9]+)/g;
+      const pathParams = [];
+      let match;
+      while ((match = pathParamRegex.exec(endpoint.path)) !== null) {
+        pathParams.push(match[1]);
+      }
+      for (const pathParam of pathParams) {
+        const paramExists = endpoint.parameters.some(
+          (param) => param.name === pathParam || param.name === pathParam.replace(/[$_]+/g, "")
+        );
+        if (!paramExists) {
+          const newParam = {
+            name: pathParam,
+            type: "Path",
+            schema: z.string().describe(`Path parameter: ${pathParam}`),
+            description: `Path parameter: ${pathParam}`
+          };
+          endpoint.parameters.push(newParam);
+        }
+      }
+      return endpoint;
+    });
+  }
+}
+export {
+  Zodios,
+  makeApi
+};

package/dist/graph-client.js

@@ -0,0 +1,208 @@
+import logger from "./logger.js";
+import { refreshAccessToken } from "./lib/microsoft-auth.js";
+import { encode as toonEncode } from "@toon-format/toon";
+import { getCloudEndpoints } from "./cloud-config.js";
+import { getRequestTokens } from "./request-context.js";
+class GraphClient {
+  constructor(authManager, secrets, outputFormat = "json") {
+    this.outputFormat = "json";
+    this.authManager = authManager;
+    this.secrets = secrets;
+    this.outputFormat = outputFormat;
+  }
+  async makeRequest(endpoint, options = {}) {
+    const contextTokens = getRequestTokens();
+    let accessToken = options.accessToken ?? contextTokens?.accessToken ?? await this.authManager.getToken();
+    const refreshToken = options.refreshToken ?? contextTokens?.refreshToken;
+    if (!accessToken) {
+      throw new Error("No access token available");
+    }
+    try {
+      let response = await this.performRequest(endpoint, accessToken, options);
+      if (response.status === 401 && refreshToken) {
+        const newTokens = await this.refreshAccessToken(refreshToken);
+        accessToken = newTokens.accessToken;
+        response = await this.performRequest(endpoint, accessToken, options);
+      }
+      if (response.status === 403) {
+        const errorText = await response.text();
+        if (errorText.includes("scope") || errorText.includes("permission")) {
+          throw new Error(
+            `Microsoft Graph API scope error: ${response.status} ${response.statusText} - ${errorText}. This tool requires organization mode. Please restart with --org-mode flag.`
+          );
+        }
+        throw new Error(
+          `Microsoft Graph API error: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+      if (!response.ok) {
+        throw new Error(
+          `Microsoft Graph API error: ${response.status} ${response.statusText} - ${await response.text()}`
+        );
+      }
+      const text = await response.text();
+      let result;
+      if (text === "") {
+        result = { message: "OK!" };
+      } else {
+        try {
+          result = JSON.parse(text);
+        } catch {
+          result = { message: "OK!", rawResponse: text };
+        }
+      }
+      if (options.includeHeaders) {
+        const etag = response.headers.get("ETag") || response.headers.get("etag");
+        if (result && typeof result === "object" && !Array.isArray(result)) {
+          return {
+            ...result,
+            _etag: etag || "no-etag-found"
+          };
+        }
+      }
+      return result;
+    } catch (error) {
+      logger.error("Microsoft Graph API request failed:", error);
+      throw error;
+    }
+  }
+  async refreshAccessToken(refreshToken) {
+    const tenantId = this.secrets.tenantId || "common";
+    const clientId = this.secrets.clientId;
+    const clientSecret = this.secrets.clientSecret;
+    if (clientSecret) {
+      logger.info("GraphClient: Refreshing token with confidential client");
+    } else {
+      logger.info("GraphClient: Refreshing token with public client");
+    }
+    const response = await refreshAccessToken(
+      refreshToken,
+      clientId,
+      clientSecret,
+      tenantId,
+      this.secrets.cloudType
+    );
+    return {
+      accessToken: response.access_token,
+      refreshToken: response.refresh_token
+    };
+  }
+  async performRequest(endpoint, accessToken, options) {
+    const cloudEndpoints = getCloudEndpoints(this.secrets.cloudType);
+    const url = `${cloudEndpoints.graphApi}/v1.0${endpoint}`;
+    const headers = {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    return fetch(url, {
+      method: options.method || "GET",
+      headers,
+      body: options.body
+    });
+  }
+  serializeData(data, outputFormat, pretty = false) {
+    if (outputFormat === "toon") {
+      try {
+        return toonEncode(data);
+      } catch (error) {
+        logger.warn(`Failed to encode as TOON, falling back to JSON: ${error}`);
+        return JSON.stringify(data, null, pretty ? 2 : void 0);
+      }
+    }
+    return JSON.stringify(data, null, pretty ? 2 : void 0);
+  }
+  async graphRequest(endpoint, options = {}) {
+    try {
+      logger.info(`Calling ${endpoint} with options: ${JSON.stringify(options)}`);
+      const result = await this.makeRequest(endpoint, options);
+      return this.formatJsonResponse(result, options.rawResponse, options.excludeResponse);
+    } catch (error) {
+      logger.error(`Error in Graph API request: ${error}`);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: error.message }) }],
+        isError: true
+      };
+    }
+  }
+  formatJsonResponse(data, rawResponse = false, excludeResponse = false) {
+    if (excludeResponse) {
+      return {
+        content: [{ type: "text", text: this.serializeData({ success: true }, this.outputFormat) }]
+      };
+    }
+    if (data && typeof data === "object" && "_headers" in data) {
+      const responseData = data;
+      const meta = {};
+      if (responseData._etag) {
+        meta.etag = responseData._etag;
+      }
+      if (responseData._headers) {
+        meta.headers = responseData._headers;
+      }
+      if (rawResponse) {
+        return {
+          content: [
+            { type: "text", text: this.serializeData(responseData.data, this.outputFormat) }
+          ],
+          _meta: meta
+        };
+      }
+      if (responseData.data === null || responseData.data === void 0) {
+        return {
+          content: [
+            { type: "text", text: this.serializeData({ success: true }, this.outputFormat) }
+          ],
+          _meta: meta
+        };
+      }
+      const removeODataProps2 = (obj) => {
+        if (typeof obj === "object" && obj !== null) {
+          Object.keys(obj).forEach((key) => {
+            if (key.startsWith("@odata.")) {
+              delete obj[key];
+            } else if (typeof obj[key] === "object") {
+              removeODataProps2(obj[key]);
+            }
+          });
+        }
+      };
+      removeODataProps2(responseData.data);
+      return {
+        content: [
+          { type: "text", text: this.serializeData(responseData.data, this.outputFormat, true) }
+        ],
+        _meta: meta
+      };
+    }
+    if (rawResponse) {
+      return {
+        content: [{ type: "text", text: this.serializeData(data, this.outputFormat) }]
+      };
+    }
+    if (data === null || data === void 0) {
+      return {
+        content: [{ type: "text", text: this.serializeData({ success: true }, this.outputFormat) }]
+      };
+    }
+    const removeODataProps = (obj) => {
+      if (typeof obj === "object" && obj !== null) {
+        Object.keys(obj).forEach((key) => {
+          if (key.startsWith("@odata.")) {
+            delete obj[key];
+          } else if (typeof obj[key] === "object") {
+            removeODataProps(obj[key]);
+          }
+        });
+      }
+    };
+    removeODataProps(data);
+    return {
+      content: [{ type: "text", text: this.serializeData(data, this.outputFormat, true) }]
+    };
+  }
+}
+var graph_client_default = GraphClient;
+export {
+  graph_client_default as default
+};

package/dist/graph-tools.js

@@ -0,0 +1,401 @@
+import logger from "./logger.js";
+import { api } from "./generated/client.js";
+import { z } from "zod";
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { TOOL_CATEGORIES } from "./tool-categories.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const endpointsData = JSON.parse(
+  readFileSync(path.join(__dirname, "endpoints.json"), "utf8")
+);
+async function executeGraphTool(tool, config, graphClient, params) {
+  logger.info(`Tool ${tool.alias} called with params: ${JSON.stringify(params)}`);
+  try {
+    const parameterDefinitions = tool.parameters || [];
+    let path2 = tool.path;
+    const queryParams = {};
+    const headers = {};
+    let body = null;
+    for (const [paramName, paramValue] of Object.entries(params)) {
+      if (["fetchAllPages", "includeHeaders", "excludeResponse", "timezone"].includes(paramName)) {
+        continue;
+      }
+      const odataParams = [
+        "filter",
+        "select",
+        "expand",
+        "orderby",
+        "skip",
+        "top",
+        "count",
+        "search",
+        "format"
+      ];
+      const normalizedParamName = paramName.startsWith("$") ? paramName.slice(1) : paramName;
+      const isOdataParam = odataParams.includes(normalizedParamName.toLowerCase());
+      const fixedParamName = isOdataParam ? `$${normalizedParamName.toLowerCase()}` : paramName;
+      const paramDef = parameterDefinitions.find(
+        (p) => p.name === paramName || isOdataParam && p.name === normalizedParamName
+      );
+      if (paramDef) {
+        switch (paramDef.type) {
+          case "Path":
+            path2 = path2.replace(`{${paramName}}`, encodeURIComponent(paramValue)).replace(`:${paramName}`, encodeURIComponent(paramValue));
+            break;
+          case "Query":
+            if (paramValue !== "" && paramValue != null) {
+              queryParams[fixedParamName] = `${paramValue}`;
+            }
+            break;
+          case "Body":
+            if (paramDef.schema) {
+              const parseResult = paramDef.schema.safeParse(paramValue);
+              if (!parseResult.success) {
+                const wrapped = { [paramName]: paramValue };
+                const wrappedResult = paramDef.schema.safeParse(wrapped);
+                if (wrappedResult.success) {
+                  logger.info(
+                    `Auto-corrected parameter '${paramName}': AI passed nested field directly, wrapped it as {${paramName}: ...}`
+                  );
+                  body = wrapped;
+                } else {
+                  body = paramValue;
+                }
+              } else {
+                body = paramValue;
+              }
+            } else {
+              body = paramValue;
+            }
+            break;
+          case "Header":
+            headers[fixedParamName] = `${paramValue}`;
+            break;
+        }
+      } else if (paramName === "body") {
+        body = paramValue;
+        logger.info(`Set body param: ${JSON.stringify(body)}`);
+      }
+    }
+    if (config?.supportsTimezone && params.timezone) {
+      headers["Prefer"] = `outlook.timezone="${params.timezone}"`;
+      logger.info(`Setting timezone header: Prefer: outlook.timezone="${params.timezone}"`);
+    }
+    if (config?.contentType) {
+      headers["Content-Type"] = config.contentType;
+      logger.info(`Setting custom Content-Type: ${config.contentType}`);
+    }
+    if (Object.keys(queryParams).length > 0) {
+      const queryString = Object.entries(queryParams).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+      path2 = `${path2}${path2.includes("?") ? "&" : "?"}${queryString}`;
+    }
+    const options = {
+      method: tool.method.toUpperCase(),
+      headers
+    };
+    if (options.method !== "GET" && body) {
+      if (config?.contentType === "text/html") {
+        if (typeof body === "string") {
+          options.body = body;
+        } else if (typeof body === "object" && "content" in body) {
+          options.body = body.content;
+        } else {
+          options.body = String(body);
+        }
+      } else {
+        options.body = typeof body === "string" ? body : JSON.stringify(body);
+      }
+    }
+    const isProbablyMediaContent = tool.errors?.some((error) => error.description === "Retrieved media content") || path2.endsWith("/content");
+    if (config?.returnDownloadUrl && path2.endsWith("/content")) {
+      path2 = path2.replace(/\/content$/, "");
+      logger.info(
+        `Auto-returning download URL for ${tool.alias} (returnDownloadUrl=true in endpoints.json)`
+      );
+    } else if (isProbablyMediaContent) {
+      options.rawResponse = true;
+    }
+    if (params.includeHeaders === true) {
+      options.includeHeaders = true;
+    }
+    if (params.excludeResponse === true) {
+      options.excludeResponse = true;
+    }
+    logger.info(`Making graph request to ${path2} with options: ${JSON.stringify(options)}`);
+    let response = await graphClient.graphRequest(path2, options);
+    const fetchAllPages = params.fetchAllPages === true;
+    if (fetchAllPages && response?.content?.[0]?.text) {
+      try {
+        let combinedResponse = JSON.parse(response.content[0].text);
+        let allItems = combinedResponse.value || [];
+        let nextLink = combinedResponse["@odata.nextLink"];
+        let pageCount = 1;
+        while (nextLink && pageCount < 100) {
+          logger.info(`Fetching page ${pageCount + 1} from: ${nextLink}`);
+          const url = new URL(nextLink);
+          const nextPath = url.pathname.replace("/v1.0", "");
+          const nextOptions = { ...options };
+          const nextQueryParams = {};
+          for (const [key, value] of url.searchParams.entries()) {
+            nextQueryParams[key] = value;
+          }
+          nextOptions.queryParams = nextQueryParams;
+          const nextResponse = await graphClient.graphRequest(nextPath, nextOptions);
+          if (nextResponse?.content?.[0]?.text) {
+            const nextJsonResponse = JSON.parse(nextResponse.content[0].text);
+            if (nextJsonResponse.value && Array.isArray(nextJsonResponse.value)) {
+              allItems = allItems.concat(nextJsonResponse.value);
+            }
+            nextLink = nextJsonResponse["@odata.nextLink"];
+            pageCount++;
+          } else {
+            break;
+          }
+        }
+        if (pageCount >= 100) {
+          logger.warn(`Reached maximum page limit (100) for pagination`);
+        }
+        combinedResponse.value = allItems;
+        if (combinedResponse["@odata.count"]) {
+          combinedResponse["@odata.count"] = allItems.length;
+        }
+        delete combinedResponse["@odata.nextLink"];
+        response.content[0].text = JSON.stringify(combinedResponse);
+        logger.info(
+          `Pagination complete: collected ${allItems.length} items across ${pageCount} pages`
+        );
+      } catch (e) {
+        logger.error(`Error during pagination: ${e}`);
+      }
+    }
+    if (response?.content?.[0]?.text) {
+      const responseText = response.content[0].text;
+      logger.info(`Response size: ${responseText.length} characters`);
+      try {
+        const jsonResponse = JSON.parse(responseText);
+        if (jsonResponse.value && Array.isArray(jsonResponse.value)) {
+          logger.info(`Response contains ${jsonResponse.value.length} items`);
+        }
+        if (jsonResponse["@odata.nextLink"]) {
+          logger.info(`Response has pagination nextLink: ${jsonResponse["@odata.nextLink"]}`);
+        }
+      } catch {
+      }
+    }
+    const content = response.content.map((item) => ({
+      type: "text",
+      text: item.text
+    }));
+    return {
+      content,
+      _meta: response._meta,
+      isError: response.isError
+    };
+  } catch (error) {
+    logger.error(`Error in tool ${tool.alias}: ${error.message}`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Error in tool ${tool.alias}: ${error.message}`
+          })
+        }
+      ],
+      isError: true
+    };
+  }
+}
+function registerGraphTools(server, graphClient, readOnly = false, enabledToolsPattern, orgMode = false) {
+  let enabledToolsRegex;
+  if (enabledToolsPattern) {
+    try {
+      enabledToolsRegex = new RegExp(enabledToolsPattern, "i");
+      logger.info(`Tool filtering enabled with pattern: ${enabledToolsPattern}`);
+    } catch {
+      logger.error(`Invalid tool filter regex pattern: ${enabledToolsPattern}. Ignoring filter.`);
+    }
+  }
+  let registeredCount = 0;
+  let skippedCount = 0;
+  let failedCount = 0;
+  for (const tool of api.endpoints) {
+    const endpointConfig = endpointsData.find((e) => e.toolName === tool.alias);
+    if (!orgMode && endpointConfig && !endpointConfig.scopes && endpointConfig.workScopes) {
+      logger.info(`Skipping work account tool ${tool.alias} - not in org mode`);
+      skippedCount++;
+      continue;
+    }
+    if (readOnly && tool.method.toUpperCase() !== "GET") {
+      logger.info(`Skipping write operation ${tool.alias} in read-only mode`);
+      skippedCount++;
+      continue;
+    }
+    if (enabledToolsRegex && !enabledToolsRegex.test(tool.alias)) {
+      logger.info(`Skipping tool ${tool.alias} - doesn't match filter pattern`);
+      skippedCount++;
+      continue;
+    }
+    const paramSchema = {};
+    if (tool.parameters && tool.parameters.length > 0) {
+      for (const param of tool.parameters) {
+        paramSchema[param.name] = param.schema || z.any();
+      }
+    }
+    if (tool.method.toUpperCase() === "GET" && tool.path.includes("/")) {
+      paramSchema["fetchAllPages"] = z.boolean().describe("Automatically fetch all pages of results").optional();
+    }
+    paramSchema["includeHeaders"] = z.boolean().describe("Include response headers (including ETag) in the response metadata").optional();
+    paramSchema["excludeResponse"] = z.boolean().describe("Exclude the full response body and only return success or failure indication").optional();
+    if (endpointConfig?.supportsTimezone) {
+      paramSchema["timezone"] = z.string().describe(
+        'IANA timezone name (e.g., "America/New_York", "Europe/London", "Asia/Tokyo") for calendar event times. If not specified, times are returned in UTC.'
+      ).optional();
+    }
+    let toolDescription = tool.description || `Execute ${tool.method.toUpperCase()} request to ${tool.path}`;
+    if (endpointConfig?.llmTip) {
+      toolDescription += `
+
+\u{1F4A1} TIP: ${endpointConfig.llmTip}`;
+    }
+    try {
+      server.tool(
+        tool.alias,
+        toolDescription,
+        paramSchema,
+        {
+          title: tool.alias,
+          readOnlyHint: tool.method.toUpperCase() === "GET",
+          destructiveHint: ["POST", "PATCH", "DELETE"].includes(tool.method.toUpperCase()),
+          openWorldHint: true
+          // All tools call Microsoft Graph API
+        },
+        async (params) => executeGraphTool(tool, endpointConfig, graphClient, params)
+      );
+      registeredCount++;
+    } catch (error) {
+      logger.error(`Failed to register tool ${tool.alias}: ${error.message}`);
+      failedCount++;
+    }
+  }
+  logger.info(
+    `Tool registration complete: ${registeredCount} registered, ${skippedCount} skipped, ${failedCount} failed`
+  );
+  return registeredCount;
+}
+function buildToolsRegistry(readOnly, orgMode) {
+  const toolsMap = /* @__PURE__ */ new Map();
+  for (const tool of api.endpoints) {
+    const endpointConfig = endpointsData.find((e) => e.toolName === tool.alias);
+    if (!orgMode && endpointConfig && !endpointConfig.scopes && endpointConfig.workScopes) {
+      continue;
+    }
+    if (readOnly && tool.method.toUpperCase() !== "GET") {
+      continue;
+    }
+    toolsMap.set(tool.alias, { tool, config: endpointConfig });
+  }
+  return toolsMap;
+}
+function registerDiscoveryTools(server, graphClient, readOnly = false, orgMode = false) {
+  const toolsRegistry = buildToolsRegistry(readOnly, orgMode);
+  logger.info(`Discovery mode: ${toolsRegistry.size} tools available in registry`);
+  server.tool(
+    "search-tools",
+    `Search through ${toolsRegistry.size} available Microsoft Graph API tools. Use this to find tools by name, path, or description before executing them.`,
+    {
+      query: z.string().describe("Search query to filter tools (searches name, path, and description)").optional(),
+      category: z.string().describe(
+        "Filter by category: mail, calendar, files, contacts, tasks, onenote, search, users, excel"
+      ).optional(),
+      limit: z.number().describe("Maximum results to return (default: 20, max: 50)").optional()
+    },
+    {
+      title: "search-tools",
+      readOnlyHint: true,
+      openWorldHint: true
+      // Searches Microsoft Graph API tools
+    },
+    async ({ query, category, limit = 20 }) => {
+      const maxLimit = Math.min(limit, 50);
+      const results = [];
+      const queryLower = query?.toLowerCase();
+      const categoryDef = category ? TOOL_CATEGORIES[category] : void 0;
+      for (const [name, { tool, config }] of toolsRegistry) {
+        if (categoryDef && !categoryDef.pattern.test(name)) {
+          continue;
+        }
+        if (queryLower) {
+          const searchText = `${name} ${tool.path} ${tool.description || ""} ${config?.llmTip || ""}`.toLowerCase();
+          if (!searchText.includes(queryLower)) {
+            continue;
+          }
+        }
+        results.push({
+          name,
+          method: tool.method.toUpperCase(),
+          path: tool.path,
+          description: tool.description || `${tool.method.toUpperCase()} ${tool.path}`
+        });
+        if (results.length >= maxLimit) break;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                found: results.length,
+                total: toolsRegistry.size,
+                tools: results,
+                tip: "Use execute-tool with the tool name and required parameters to call any of these tools."
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "execute-tool",
+    "Execute a Microsoft Graph API tool by name. Use search-tools first to find available tools and their parameters.",
+    {
+      tool_name: z.string().describe('Name of the tool to execute (e.g., "list-mail-messages")'),
+      parameters: z.record(z.any()).describe("Parameters to pass to the tool as key-value pairs").optional()
+    },
+    {
+      title: "execute-tool",
+      readOnlyHint: false,
+      destructiveHint: true,
+      // Can execute any tool, including write operations
+      openWorldHint: true
+      // Executes against Microsoft Graph API
+    },
+    async ({ tool_name, parameters = {} }) => {
+      const toolData = toolsRegistry.get(tool_name);
+      if (!toolData) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Tool not found: ${tool_name}`,
+                tip: "Use search-tools to find available tools."
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      return executeGraphTool(toolData.tool, toolData.config, graphClient, parameters);
+    }
+  );
+}
+export {
+  registerDiscoveryTools,
+  registerGraphTools
+};