@softeria/ms-365-mcp-server 0.143.0 → 0.145.0

package/dist/auth-tools.js

@@ -34,7 +34,6 @@ function registerAuthTools(server, authManager) {
                 type: "text",
                 text: JSON.stringify({
                   status: "Login successful",
-                  message: "Browser authentication completed successfully.",
                   ...loginResult
                 })
               }

package/dist/graph-client.js

@@ -31,6 +31,62 @@ function isBinaryContentType(contentType) {
   }
   return false;
 }
+class GraphApiError extends Error {
+  constructor(message, httpStatus, graphErrorCode) {
+    super(message);
+    this.name = "GraphApiError";
+    this.httpStatus = httpStatus;
+    this.graphErrorCode = graphErrorCode;
+  }
+}
+function extractGraphErrorCode(errorText) {
+  try {
+    const body = JSON.parse(errorText);
+    const code = body.error?.code ?? body.code;
+    return typeof code === "string" ? code : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function definedMetadata(metadata) {
+  return Object.fromEntries(
+    Object.entries(metadata).filter(([, value]) => value !== void 0)
+  );
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function incrementCount(counts, key) {
+  counts[key] = (counts[key] ?? 0) + 1;
+}
+function extractGraphErrorCodeFromBody(body) {
+  if (!isRecord(body)) return void 0;
+  const error = body.error;
+  const code = isRecord(error) ? error.code : body.code;
+  return typeof code === "string" ? code : void 0;
+}
+function extractBatchMetadata(data) {
+  if (!isRecord(data) || !Array.isArray(data.responses)) return {};
+  const httpStatusCounts = {};
+  const errorCodeCounts = {};
+  for (const item of data.responses) {
+    if (!isRecord(item)) continue;
+    const status = item.status;
+    if (typeof status !== "number" || !Number.isInteger(status)) continue;
+    incrementCount(httpStatusCounts, String(status));
+    if (status >= 400) {
+      const errorCode = extractGraphErrorCodeFromBody(item.body);
+      if (errorCode) {
+        incrementCount(errorCodeCounts, errorCode);
+      }
+    }
+  }
+  return {
+    graph_batch_subrequest_count: data.responses.length,
+    ...Object.keys(httpStatusCounts).length > 0 ? { graph_batch_http_status_counts: httpStatusCounts } : {},
+    ...Object.keys(errorCodeCounts).length > 0 ? { graph_batch_error_code_counts: errorCodeCounts } : {}
+  };
+}
 class GraphClient {
   constructor(authManager, secrets, outputFormat = "json") {
     this.outputFormat = "json";
@@ -39,6 +95,9 @@ class GraphClient {
     this.outputFormat = outputFormat;
   }
   async makeRequest(endpoint, options = {}) {
+    return (await this.makeRequestWithMetadata(endpoint, options)).data;
+  }
+  async makeRequestWithMetadata(endpoint, options = {}) {
     const contextTokens = getRequestTokens();
     const accessToken = options.accessToken ?? contextTokens?.accessToken ?? await this.authManager.getToken();
     if (!accessToken) {
@@ -47,23 +106,14 @@ class GraphClient {
     try {
       const 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}`
-        );
+        throw await this.createGraphApiError(response);
       }
       if (!response.ok) {
-        throw new Error(
-          `Microsoft Graph API error: ${response.status} ${response.statusText} - ${await response.text()}`
-        );
+        throw await this.createGraphApiError(response);
       }
       const contentTypeHeader = response.headers?.get?.("content-type") || "";
       const isBinaryResponse = isBinaryContentType(contentTypeHeader);
+      let metadata = { http_status: response.status };
       let result;
       if (isBinaryResponse) {
         const buffer = Buffer.from(await response.arrayBuffer());
@@ -88,16 +138,22 @@ class GraphClient {
           }
         }
       }
+      if (endpoint === "/$batch") {
+        metadata = { ...metadata, ...extractBatchMetadata(result) };
+      }
       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"
+            data: {
+              ...result,
+              _etag: etag || "no-etag-found"
+            },
+            metadata
           };
         }
       }
-      return result;
+      return { data: result, metadata };
     } catch (error) {
       logger.error("Microsoft Graph API request failed:", error);
       throw error;
@@ -121,20 +177,10 @@ class GraphClient {
       }
       const 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}`
-        );
+        throw await this.createGraphApiError(response);
       }
       if (!response.ok) {
-        throw new Error(
-          `Microsoft Graph API error: ${response.status} ${response.statusText} - ${await response.text()}`
-        );
+        throw await this.createGraphApiError(response);
       }
       if (!response.body) {
         throw new Error("Microsoft Graph returned an empty response body");
@@ -150,7 +196,8 @@ class GraphClient {
       }
       return {
         contentType: response.headers.get("content-type") || "application/octet-stream",
-        contentLength
+        contentLength,
+        httpStatus: response.status
       };
     } catch (error) {
       logger.error("Microsoft Graph file download failed:", error);
@@ -162,6 +209,23 @@ class GraphClient {
       }
     }
   }
+  async createGraphApiError(response) {
+    const errorText = await response.text();
+    const graphErrorCode = extractGraphErrorCode(errorText);
+    const isPermissionOrScopeError = errorText.includes("scope") || errorText.includes("permission");
+    if (response.status === 403 && isPermissionOrScopeError) {
+      return new GraphApiError(
+        `Microsoft Graph API scope error: ${response.status} ${response.statusText} - ${errorText}. This tool requires organization mode. Please restart with --org-mode flag.`,
+        response.status,
+        graphErrorCode
+      );
+    }
+    return new GraphApiError(
+      `Microsoft Graph API error: ${response.status} ${response.statusText} - ${errorText}`,
+      response.status,
+      graphErrorCode
+    );
+  }
   async performRequest(endpoint, accessToken, options) {
     const cloudEndpoints = getCloudEndpoints(this.secrets.cloudType);
     const apiVersion = options.apiVersion || "v1.0";
@@ -211,22 +275,36 @@ class GraphClient {
       logger.info(
         `Calling ${endpoint} with options: ${JSON.stringify(safeOptions)}${_redacted ? " [accessToken=REDACTED]" : ""}`
       );
-      const result = await this.makeRequest(endpoint, options);
+      const { data, metadata } = await this.makeRequestWithMetadata(endpoint, options);
       const outputFormat = options.forceJsonOutput ? "json" : this.outputFormat;
-      return this.formatJsonResponse(
-        result,
-        options.rawResponse,
-        options.excludeResponse,
-        outputFormat
+      return this.withResponseMetadata(
+        this.formatJsonResponse(data, options.rawResponse, options.excludeResponse, outputFormat),
+        metadata
       );
     } catch (error) {
       logger.error(`Error in Graph API request: ${error}`);
+      const metadata = error instanceof GraphApiError ? definedMetadata({
+        http_status: error.httpStatus,
+        error_code: error.graphErrorCode
+      }) : void 0;
       return {
         content: [{ type: "text", text: JSON.stringify({ error: error.message }) }],
-        isError: true
+        isError: true,
+        ...metadata && Object.keys(metadata).length > 0 ? { _meta: metadata } : {}
       };
     }
   }
+  withResponseMetadata(response, metadata) {
+    const cleanMetadata = definedMetadata(metadata);
+    if (Object.keys(cleanMetadata).length === 0) return response;
+    return {
+      ...response,
+      _meta: {
+        ...response._meta,
+        ...cleanMetadata
+      }
+    };
+  }
   formatJsonResponse(data, rawResponse = false, excludeResponse = false, outputFormat = this.outputFormat) {
     if (excludeResponse) {
       return {
@@ -302,6 +380,7 @@ class GraphClient {
 }
 var graph_client_default = GraphClient;
 export {
+  GraphApiError,
   graph_client_default as default,
   isBinaryContentType
 };

package/dist/graph-tools.js

@@ -1,3 +1,4 @@
+import { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { randomUUID } from "crypto";
 import logger from "./logger.js";
 import { auditLog, getUserIdentityForAudit } from "./audit-log.js";
@@ -76,11 +77,172 @@ const DEFAULT_MAX_ITEMS = 1e4;
 function isConfirmGateEnabled() {
   return process.env.MS365_MCP_REQUIRE_CONFIRM === "true";
 }
+function auditHttpStatus(value) {
+  if (typeof value === "number" && Number.isInteger(value)) return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) return Number(value);
+  return void 0;
+}
+function auditErrorCode(value) {
+  return typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+function auditNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function auditStringNumberMap(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const entries = Object.entries(value).filter(
+    (entry) => typeof entry[1] === "number" && Number.isInteger(entry[1]) && entry[1] >= 0
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function graphResponseAuditFields(response) {
+  const httpStatus = auditHttpStatus(response._meta?.http_status);
+  const errorCode = response.isError ? auditErrorCode(response._meta?.error_code) : void 0;
+  const graphBatchSubrequestCount = auditNonNegativeInteger(
+    response._meta?.graph_batch_subrequest_count
+  );
+  const graphBatchHttpStatusCounts = auditStringNumberMap(
+    response._meta?.graph_batch_http_status_counts
+  );
+  const graphBatchErrorCodeCounts = auditStringNumberMap(
+    response._meta?.graph_batch_error_code_counts
+  );
+  return {
+    ...httpStatus !== void 0 ? { http_status: httpStatus } : {},
+    ...errorCode !== void 0 ? { error_code: errorCode } : {},
+    ...graphBatchSubrequestCount !== void 0 ? { graph_batch_subrequest_count: graphBatchSubrequestCount } : {},
+    ...graphBatchHttpStatusCounts !== void 0 ? { graph_batch_http_status_counts: graphBatchHttpStatusCounts } : {},
+    ...graphBatchErrorCodeCounts !== void 0 ? { graph_batch_error_code_counts: graphBatchErrorCodeCounts } : {}
+  };
+}
+function thrownErrorAuditFields(error) {
+  const err = error;
+  const httpStatus = auditHttpStatus(err?.httpStatus ?? err?.status);
+  const errorCode = auditErrorCode(err?.graphErrorCode ?? err?.code ?? err?.status);
+  return {
+    ...httpStatus !== void 0 ? { http_status: httpStatus } : {},
+    ...errorCode !== void 0 ? { error_code: errorCode } : {}
+  };
+}
+async function executeUtilityTool(utility, ctx, params) {
+  const requestId = randomUUID();
+  const startTime = Date.now();
+  const upn = getUserIdentityForAudit(getRequestTokens()?.accessToken);
+  try {
+    const response = await utility.execute(params, ctx);
+    auditLog({
+      event: "tool.call",
+      request_id: requestId,
+      user_principal_name: upn,
+      tool: utility.name,
+      http_method: utility.method.toUpperCase(),
+      status: response.isError ? "error" : "success",
+      duration_ms: Date.now() - startTime,
+      ...graphResponseAuditFields(response)
+    });
+    return response;
+  } catch (error) {
+    const err = error;
+    auditLog({
+      event: "tool.call",
+      request_id: requestId,
+      user_principal_name: upn,
+      tool: utility.name,
+      http_method: utility.method.toUpperCase(),
+      status: "error",
+      duration_ms: Date.now() - startTime,
+      error_type: err?.name || "Error",
+      ...thrownErrorAuditFields(error)
+    });
+    throw error;
+  }
+}
 function formatDisabledToolsForLog(disabledTools) {
   const shown = disabledTools.slice(0, 20).map((tool) => `${tool.toolName} (missing: ${tool.missingScopes.join(", ")})`);
   const suffix = disabledTools.length > shown.length ? `, ... +${disabledTools.length - shown.length} more` : "";
   return `${shown.join("; ")}${suffix}`;
 }
+function deniedToolPolicyForGraphTool(tool, config, reason, missingScopes) {
+  return {
+    toolName: tool.alias,
+    reason,
+    ...missingScopes && missingScopes.length > 0 ? { missingScopes } : {},
+    pathPattern: config?.pathPattern ?? tool.path
+  };
+}
+function collectDeniedToolPolicies(options) {
+  const deniedTools = /* @__PURE__ */ new Map();
+  const allowedScopes = parseAllowedScopes(options.allowedScopesValue);
+  for (const tool of allEndpoints) {
+    const endpointConfig = endpointsData.find((e) => e.toolName === tool.alias);
+    if (!options.orgMode && endpointConfig && !endpointConfig.scopes && endpointConfig.workScopes) {
+      continue;
+    }
+    const method = tool.method.toUpperCase();
+    if (options.readOnly && method !== "GET" && !(method === "POST" && endpointConfig?.readOnly)) {
+      continue;
+    }
+    if (options.enabledToolsRegex && !options.enabledToolsRegex.test(tool.alias)) {
+      deniedTools.set(
+        tool.alias,
+        deniedToolPolicyForGraphTool(tool, endpointConfig, "tool_allowlist")
+      );
+      continue;
+    }
+    const missingScopes = allowedScopes !== void 0 && !endpointConfig ? ["endpoint scope metadata"] : getMissingAllowedScopesForGroups(
+      getEndpointScopeGroups(endpointConfig, options.orgMode),
+      allowedScopes
+    );
+    if (missingScopes.length > 0) {
+      deniedTools.set(
+        tool.alias,
+        deniedToolPolicyForGraphTool(tool, endpointConfig, "allowed_scopes", missingScopes)
+      );
+    }
+  }
+  for (const utility of UTILITY_TOOLS) {
+    if (options.readOnly && !utility.readOnlyHint) continue;
+    if (options.httpMode && utility.stdioOnly) continue;
+    if (options.enabledToolsRegex && !options.enabledToolsRegex.test(utility.name)) {
+      deniedTools.set(utility.name, {
+        toolName: utility.name,
+        reason: "tool_allowlist"
+      });
+    }
+  }
+  return deniedTools;
+}
+function auditToolDenied(policy, params = {}) {
+  const targetResource = policy.pathPattern ? deriveTargetResource({ pathPattern: policy.pathPattern, params }) : void 0;
+  auditLog({
+    event: "tool.denied",
+    request_id: randomUUID(),
+    user_principal_name: getUserIdentityForAudit(getRequestTokens()?.accessToken),
+    tool: policy.toolName,
+    status: "denied",
+    reason: policy.reason,
+    ...policy.missingScopes ? { missing_scopes: policy.missingScopes } : {},
+    ...targetResource ? { target_resource: targetResource } : {}
+  });
+}
+function installDeniedToolAuditHandler(server, deniedTools) {
+  if (deniedTools.size === 0) return;
+  const lowLevel = server.server;
+  const handlers = lowLevel._requestHandlers;
+  const original = handlers?.get("tools/call");
+  if (!original) {
+    logger.warn("Skipping denied-tool audit hook: tools/call handler not found");
+    return;
+  }
+  lowLevel.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+    const policy = deniedTools.get(request.params.name);
+    if (policy) {
+      const params = request.params.arguments && typeof request.params.arguments === "object" ? request.params.arguments : {};
+      auditToolDenied(policy, params);
+    }
+    return original(request, extra);
+  });
+}
 async function checkAccountParamInBearerMode(accountParam, authManager) {
   if (!accountParam || !authManager) return null;
   const contextToken = getRequestTokens()?.accessToken;
@@ -316,12 +478,15 @@ const UTILITY_TOOLS = [
                 bytesWritten: result.contentLength
               })
             }
-          ]
+          ],
+          ...result.httpStatus !== void 0 ? { _meta: { http_status: result.httpStatus } } : {}
         };
       } catch (error) {
+        const metadata = thrownErrorAuditFields(error);
         return {
           content: [{ type: "text", text: JSON.stringify({ error: error.message }) }],
-          isError: true
+          isError: true,
+          ...Object.keys(metadata).length > 0 ? { _meta: metadata } : {}
         };
       }
     }
@@ -496,7 +661,8 @@ const UTILITY_TOOLS = [
                 })
               }
             ],
-            isError: true
+            isError: true,
+            _meta: response._meta
           };
         }
         const file = item?.file;
@@ -511,12 +677,15 @@ const UTILITY_TOOLS = [
                 contentType: file?.mimeType
               })
             }
-          ]
+          ],
+          _meta: response._meta
         };
       } catch (error) {
+        const metadata = thrownErrorAuditFields(error);
         return {
           content: [{ type: "text", text: JSON.stringify({ error: error.message }) }],
-          isError: true
+          isError: true,
+          ...Object.keys(metadata).length > 0 ? { _meta: metadata } : {}
         };
       }
     }
@@ -532,7 +701,7 @@ function registerUtilityToolWithMcp(server, utility, ctx) {
       readOnlyHint: utility.readOnlyHint ?? true,
       openWorldHint: utility.openWorldHint ?? true
     },
-    async (params) => utility.execute(params, ctx)
+    async (params) => executeUtilityTool(utility, ctx, params)
   );
 }
 function namesNestedBodyType(value) {
@@ -886,6 +1055,11 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
             const nextPath = url.pathname.replace(/^\/(v1\.0|beta)/, "") + url.search;
             const nextOptions = { ...options };
             const nextResponse = await graphClient.graphRequest(nextPath, nextOptions);
+            if (nextResponse?.isError) {
+              response = nextResponse;
+              combinedResponse = void 0;
+              break;
+            }
             if (nextResponse?.content?.[0]?.text) {
               const nextJsonResponse = JSON.parse(nextResponse.content[0].text);
               if (Array.isArray(nextJsonResponse.value)) {
@@ -900,25 +1074,27 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
               break;
             }
           }
-          if (pageCount >= maxPages) {
-            logger.warn(`Reached maximum page limit (${maxPages}) for pagination`);
-          }
-          if (allItems.length >= maxItems) {
-            logger.warn(
-              `Reached maximum item limit (${maxItems}) for pagination \u2014 truncated at ${allItems.length} items`
+          if (combinedResponse !== void 0) {
+            if (pageCount >= maxPages) {
+              logger.warn(`Reached maximum page limit (${maxPages}) for pagination`);
+            }
+            if (allItems.length >= maxItems) {
+              logger.warn(
+                `Reached maximum item limit (${maxItems}) for pagination \u2014 truncated at ${allItems.length} items`
+              );
+            }
+            combinedResponse.value = allItems;
+            if (combinedResponse["@odata.count"]) {
+              combinedResponse["@odata.count"] = allItems.length;
+            }
+            delete combinedResponse["@odata.nextLink"];
+            if (deltaLink) {
+              combinedResponse["@odata.deltaLink"] = deltaLink;
+            }
+            logger.info(
+              `Pagination complete: collected ${allItems.length} items across ${pageCount} pages`
             );
           }
-          combinedResponse.value = allItems;
-          if (combinedResponse["@odata.count"]) {
-            combinedResponse["@odata.count"] = allItems.length;
-          }
-          delete combinedResponse["@odata.nextLink"];
-          if (deltaLink) {
-            combinedResponse["@odata.deltaLink"] = deltaLink;
-          }
-          logger.info(
-            `Pagination complete: collected ${allItems.length} items across ${pageCount} pages`
-          );
         }
       } catch (e) {
         logger.error(`Error during pagination: ${e}`);
@@ -953,7 +1129,8 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
       http_method: httpMethod,
       status: response.isError ? "error" : "success",
       duration_ms: Date.now() - startTime,
-      ...targetResource ? { target_resource: targetResource } : {}
+      ...targetResource ? { target_resource: targetResource } : {},
+      ...graphResponseAuditFields(response)
     });
     return {
       content,
@@ -973,7 +1150,7 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
       duration_ms: Date.now() - startTime,
       ...targetResource ? { target_resource: targetResource } : {},
       error_type: err?.name || "Error",
-      error_code: err?.status ?? err?.code
+      ...thrownErrorAuditFields(error)
     });
     return {
       content: [
@@ -1003,6 +1180,13 @@ function registerGraphTools(server, graphClient, readOnly = false, enabledToolsP
   let failedCount = 0;
   const allowedScopes = parseAllowedScopes(allowedScopesValue);
   const disabledByAllowedScopes = [];
+  const deniedTools = collectDeniedToolPolicies({
+    readOnly,
+    orgMode,
+    enabledToolsRegex,
+    allowedScopesValue,
+    httpMode
+  });
   for (const tool of allEndpoints) {
     const endpointConfig = endpointsData.find((e) => e.toolName === tool.alias);
     if (!orgMode && endpointConfig && !endpointConfig.scopes && endpointConfig.workScopes) {
@@ -1161,6 +1345,7 @@ function registerGraphTools(server, graphClient, readOnly = false, enabledToolsP
   logger.info(
     `Tool registration complete: ${registeredCount} registered, ${skippedCount} skipped, ${failedCount} failed`
   );
+  installDeniedToolAuditHandler(server, deniedTools);
   return registeredCount;
 }
 function buildToolsRegistry(readOnly, orgMode, enabledToolsRegex, allowedScopesValue, disabledByAllowedScopes = []) {
@@ -1277,6 +1462,13 @@ function registerDiscoveryTools(server, graphClient, readOnly = false, orgMode =
     }
   }
   const disabledByAllowedScopes = [];
+  const deniedTools = collectDeniedToolPolicies({
+    readOnly,
+    orgMode,
+    enabledToolsRegex,
+    allowedScopesValue,
+    httpMode
+  });
   const toolsRegistry = buildToolsRegistry(
     readOnly,
     orgMode,
@@ -1450,7 +1642,11 @@ function registerDiscoveryTools(server, graphClient, readOnly = false, orgMode =
       }
       const utility = utilityByName.get(tool_name);
       if (utility) {
-        return utility.execute(parameters, utilityCtx);
+        return executeUtilityTool(utility, utilityCtx, parameters);
+      }
+      const deniedPolicy = deniedTools.get(tool_name);
+      if (deniedPolicy) {
+        auditToolDenied(deniedPolicy, parameters);
       }
       return {
         content: [
@@ -1466,6 +1662,7 @@ function registerDiscoveryTools(server, graphClient, readOnly = false, orgMode =
       };
     }
   );
+  installDeniedToolAuditHandler(server, deniedTools);
 }
 export {
   UTILITY_TOOLS,

package/docs/deployment.md

@@ -213,7 +213,7 @@ The client automatically discovers OAuth endpoints and opens a browser for authe
 - **Tool filtering**: use `--enabled-tools <regex>` or `--preset <names>` to restrict available tools
 - **CORS**: configure `MS365_MCP_CORS_ORIGIN` to restrict allowed origins (defaults to `http://localhost:3000`); set explicitly when clients run on a different origin
 - **Disable Dynamic Client Registration**: when only a known client talks to the server, set `MS365_MCP_DISABLE_DCR=true` (or pass `--no-dynamic-registration`) to close the anonymous `/register` endpoint
-- **Structured audit log**: enabled by default. Every tool invocation emits one JSON line on stderr (captured by the container platform's log collector) and to `~/.ms-365-mcp-server/logs/audit.log` (mode `0o600`) with `{ event, request_id, user_principal_name, tool, http_method, status, duration_ms, target_resource?, error_type?, error_code? }`. When an audited generated Microsoft Graph tool targets a derivable resource through an ID-like path parameter such as `{message-id}` or `{driveItem-id}`, `target_resource` is `{ type, id }`, where `id` is the Graph path up to that resource ID. Later path parameters such as `{path}`, query values, tool parameters, returned content, and Graph response bodies are NEVER recorded, and error messages are reduced to `error_type` / `error_code` so upstream library errors do not leak token fragments or query-string PII. Forms the "who accessed what, when" trail required for GDPR / HIPAA / PIPEDA / SOC 2 audit. Opt-out: `MS365_MCP_AUDIT_LOG=false`
+- **Structured audit log**: enabled by default. Every tool invocation emits one JSON line on stderr (captured by the container platform's log collector) and to `~/.ms-365-mcp-server/logs/audit.log` (mode `0o600`) with `{ event, request_id, user_principal_name, tool, http_method, status, duration_ms, target_resource?, error_type?, error_code? }`. Policy-blocked tool attempts emit `event: "tool.denied"` with `status: "denied"`, `reason` (`allowed_scopes` or `tool_allowlist`), and `missing_scopes` when applicable. When an audited generated Microsoft Graph tool targets a derivable resource through an ID-like path parameter such as `{message-id}` or `{driveItem-id}`, `target_resource` is `{ type, id }`, where `id` is the Graph path up to that resource ID. Later path parameters such as `{path}`, query values, tool parameters, returned content, and Graph response bodies are NEVER recorded, and error messages are reduced to `error_type` / `error_code` so upstream library errors do not leak token fragments or query-string PII. Forms the "who accessed what, when" trail required for GDPR / HIPAA / PIPEDA / SOC 2 audit. Opt-out: `MS365_MCP_AUDIT_LOG=false`
 - **Graph resilience**: every call to Microsoft Graph is wrapped with a fetch timeout (default 100 s via `MS365_MCP_GRAPH_TIMEOUT_MS`), retry-with-backoff on 429 / 503 / 504 / network errors (default 3 retries, full-jitter exponential backoff, honours `Retry-After`; 503 / 504 / network errors only retried for idempotent methods, 429 retried on all methods), and a process-wide circuit breaker that opens after 5 consecutive failures and cools down for 30 s (`MS365_MCP_GRAPH_CIRCUIT_THRESHOLD` / `MS365_MCP_GRAPH_CIRCUIT_COOLDOWN_MS`). Disable the breaker for trusted automation: `MS365_MCP_GRAPH_CIRCUIT_DISABLED=true`
 - **Confirm gate on destructive tools**: opt-in, **off by default**. Enable with `MS365_MCP_REQUIRE_CONFIRM=true`. When on, destructive tools (POST except `readOnly`, PATCH, PUT, DELETE — `delete-mail-message`, `send-mail`, `update-event`, etc.) return `{ "error": "confirmation_required" }` until the caller re-invokes them with `"confirm": true`. Mitigates accidental writes when an LLM misroutes a request or follows an injected instruction. Shipped opt-in so it is a non-breaking, additive layer that can coexist with client-side elicitation prompts (MCP Elicitation API) where the client supports them.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@softeria/ms-365-mcp-server",
   "mcpName": "io.github.Softeria/ms-365-mcp-server",
-  "version": "0.143.0",
+  "version": "0.145.0",
   "description": " A Model Context Protocol (MCP) server for interacting with Microsoft 365 and Office services through the Graph API",
   "type": "module",
   "main": "dist/index.js",
@@ -19,7 +19,8 @@
     "format:check": "prettier --check \"**/*.{ts,mts,js,mjs,json,md}\"",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "verify": "npm run generate && npm run lint && npm run format:check && npm run build && npm run test",
+    "typecheck": "tsc --noEmit",
+    "verify": "npm run generate && npm run lint && npm run format:check && npm run typecheck && npm run build && npm run test",
     "inspector": "npx @modelcontextprotocol/inspector tsx src/index.ts"
   },
   "keywords": [