@softeria/ms-365-mcp-server 0.157.2 → 0.158.1

package/dist/generated/client.js

@@ -2688,7 +2688,16 @@ const microsoft_graph_subscription = z.object({
   ).nullish(),
   resource: z.string().describe(
     "Required. Specifies the resource that is monitored for changes. Don't include the base URL (https://graph.microsoft.com/v1.0/). See the possible resource path values for each supported resource."
-  ).optional()
+  ).optional(),
+  vapidPublicKey: z.string().describe(
+    "Optional. The application server's VAPID public key, base64url-encoded (P-256 uncompressed point, 65 bytes pre-encoding). Obtained by calling the getVapidPublicKey function on the subscription collection. The browser passes this value to PushManager.subscribe({ applicationServerKey: vapidPublicKey }) to bind the push subscription to this server identity. Required when notificationUrl targets a known Web Push service origin (for example, *.push.apple.com, fcm.googleapis.com, updates.push.services.mozilla.com); rejected with 400 Bad Request if supplied on a standard webhook subscription. For more information, see RFC 8292."
+  ).nullish(),
+  webPushEncryptionP256dhPublicKey: z.string().describe(
+    "Optional. The subscriber's ECDH public key, base64url-encoded (P-256 uncompressed point, 65 bytes pre-encoding). Obtained from the browser via PushSubscription.getKey('p256dh'). Used as the peer public key during ECDH key agreement to derive the per-message content encryption key for RFC 8291 payload encryption. Required when notificationUrl targets a known Web Push service origin; rejected with 400 Bad Request if supplied on a standard webhook subscription. For more information, see RFC 8291 Section 3."
+  ).nullish(),
+  webPushEncryptionSecret: z.string().describe(
+    "Optional. The subscriber's auth secret, base64url-encoded (16 bytes pre-encoding). Obtained from the browser via PushSubscription.getKey('auth'). Used as the HMAC-SHA-256 salt for the HKDF combine step that derives key material for RFC 8291 payload encryption. Write-only: this value is never returned in GET responses (returned as null). Treat as a secret. Required when notificationUrl targets a known Web Push service origin; rejected with 400 Bad Request if supplied on a standard webhook subscription. For more information, see RFC 8291 Section 3."
+  ).nullish()
 }).passthrough();
 const microsoft_graph_list = z.lazy(
   () => z.object({

package/dist/graph-tools.js

@@ -1,58 +1,67 @@
 import { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { randomUUID } from "crypto";
-import logger from "./logger.js";
+import { readFileSync } from "fs";
+import { access } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
 import { auditLog, getUserIdentityForAudit } from "./audit-log.js";
-import { isDestructiveOperation } from "./lib/destructive-ops.js";
-import { describePathParam } from "./lib/path-params.js";
-import { getAttachmentMinting } from "./lib/attachment-minting.js";
-import {
-  buildAttachmentUrl,
-  isPlainGraphPath,
-  TicketStoreFullError
-} from "./lib/attachment-tickets.js";
-import {
-  anyFieldPresent,
-  isTransportEnvelope,
-  parseSelectFields,
-  projectSelectedFields
-} from "./lib/select-projection.js";
+import { deriveTargetResource } from "./audit-target-resource.js";
 import {
   getEndpointScopeGroups,
   getMissingAllowedScopesForGroups,
   parseAllowedScopes
 } from "./auth.js";
-import { api } from "./generated/client.js";
 import { api as betaApi } from "./generated/client-beta.js";
-const allEndpoints = [...api.endpoints, ...betaApi.endpoints];
-import { z } from "zod";
-import { readFileSync } from "fs";
-import { access } from "fs/promises";
-import path from "path";
-import { fileURLToPath } from "url";
-import { TOOL_CATEGORIES } from "./tool-categories.js";
-import { getRequestTokens } from "./request-context.js";
-import { parseTeamsUrl } from "./lib/teams-url-parser.js";
+import { api } from "./generated/client.js";
+import { getAttachmentMinting } from "./lib/attachment-minting.js";
+import {
+  buildAttachmentUrl,
+  isPlainGraphPath,
+  isUnalteredGraphPath,
+  TicketStoreFullError
+} from "./lib/attachment-tickets.js";
 import { buildBM25Index, scoreQuery, tokenize } from "./lib/bm25.js";
-import { deriveTargetResource } from "./audit-target-resource.js";
-import { describeToolSchema, describeUtilityToolSchema } from "./lib/tool-schema.js";
-import { queryParameterSchema } from "./lib/query-parameter-schema.js";
+import { isDestructiveOperation } from "./lib/destructive-ops.js";
 import {
-  TOP_UNSUPPORTED_DELTA_TOOLS,
-  shouldOmitTopParam,
-  paginationAllowed,
-  positiveIntFromEnv,
-  DEFAULT_MAX_PAGES,
-  getMaxPages,
-  isFetchAllPagesApplicable,
   CONFIRM_PARAM_DESCRIPTION,
-  TIMEZONE_PARAM_DESCRIPTION,
+  DEFAULT_MAX_PAGES,
   EXPAND_EXTENDED_PROPERTIES_PARAM_DESCRIPTION,
   getAcceptParamDescription,
   getAccountParamDescription,
   getFetchAllPagesParamDescription,
+  getMaxPages,
+  isFetchAllPagesApplicable,
+  isSkiptokenApplicable,
+  paginationAllowed,
+  positiveIntFromEnv,
+  shouldOmitTopParam,
   SKIPTOKEN_PARAM_DESCRIPTION,
-  isSkiptokenApplicable
+  TIMEZONE_PARAM_DESCRIPTION,
+  TOP_UNSUPPORTED_DELTA_TOOLS
 } from "./lib/param-descriptions.js";
+import { describePathParam } from "./lib/path-params.js";
+import { queryParameterSchema } from "./lib/query-parameter-schema.js";
+import {
+  anyFieldPresent,
+  isTransportEnvelope,
+  parseSelectFields,
+  projectSelectedFields
+} from "./lib/select-projection.js";
+import { parseTeamsUrl } from "./lib/teams-url-parser.js";
+import { describeToolSchema, describeUtilityToolSchema } from "./lib/tool-schema.js";
+import {
+  restrictUserFieldQuery,
+  restrictUserFieldUrl,
+  shouldStripUserFieldExpand,
+  stripUserFieldExpandFromUrl,
+  targetsUserProfile,
+  userFieldEnforcement
+} from "./lib/user-field-policy.js";
+import logger from "./logger.js";
+import { getRequestTokens } from "./request-context.js";
+import { TOOL_CATEGORIES } from "./tool-categories.js";
+const allEndpoints = [...api.endpoints, ...betaApi.endpoints];
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const endpointsData = JSON.parse(
@@ -81,6 +90,16 @@ function clampTopQueryParam(queryParams) {
   logger.info(`Clamping $top from ${requested} to ${cap} (MS365_MCP_MAX_TOP)`);
   queryParams["$top"] = String(cap);
 }
+function parseUserFields(value) {
+  if (value === void 0) return void 0;
+  const fields = value.split(",").map((field) => field.trim()).filter(Boolean);
+  if (fields.length === 0) {
+    throw new Error(
+      "User field allowlist was configured but names no fields. Provide one or more comma-separated Graph fields, or omit --user-fields / MS365_MCP_USER_FIELDS."
+    );
+  }
+  return fields;
+}
 const OUTLOOK_MAIL_PATH = /^\/(?:me|users\/[^/]+)(?:\/(?:mailFolders|childFolders)\/[^/]+)*\/messages(?:\/delta\(\))?$/i;
 function isOutlookMailPath(path2) {
   return OUTLOOK_MAIL_PATH.test(path2);
@@ -640,7 +659,7 @@ const UTILITY_TOOLS = [
       }
       return schema;
     },
-    execute: async (params, { graphClient, authManager }) => {
+    execute: async (params, { graphClient, authManager, userFields }) => {
       const target = params.target;
       const accountParam = params.account;
       if (typeof target !== "string" || target.length === 0) {
@@ -667,6 +686,10 @@ const UTILITY_TOOLS = [
           isError: true
         };
       }
+      const alteredTarget = unalteredTargetError(target);
+      if (alteredTarget) return alteredTarget;
+      const restrictedTarget = userProfilePassthroughError(target, userFields);
+      if (restrictedTarget) return restrictedTarget;
       try {
         const accountModeError = await checkAccountParamInBearerMode(accountParam, authManager);
         if (accountModeError) {
@@ -721,7 +744,7 @@ const UTILITY_TOOLS = [
       }
       return schema;
     },
-    execute: async (params, { graphClient, authManager }) => {
+    execute: async (params, { graphClient, authManager, userFields }) => {
       const target = params.target;
       const outputPath = params.outputPath;
       const accountParam = params.account;
@@ -762,6 +785,10 @@ const UTILITY_TOOLS = [
           isError: true
         };
       }
+      const alteredTarget = unalteredTargetError(target);
+      if (alteredTarget) return alteredTarget;
+      const restrictedTarget = userProfilePassthroughError(target, userFields);
+      if (restrictedTarget) return restrictedTarget;
       if (!path.isAbsolute(outputPath)) {
         return {
           content: [
@@ -858,7 +885,7 @@ const UTILITY_TOOLS = [
       }
       return schema;
     },
-    execute: async (params, { graphClient, authManager }) => {
+    execute: async (params, { graphClient, authManager, userFields }) => {
       const target = params.target;
       const accountParam = params.account;
       if (typeof target !== "string" || target.length === 0) {
@@ -885,6 +912,10 @@ const UTILITY_TOOLS = [
           isError: true
         };
       }
+      const alteredTarget = unalteredTargetError(target);
+      if (alteredTarget) return alteredTarget;
+      const restrictedTarget = userProfilePassthroughError(target, userFields);
+      if (restrictedTarget) return restrictedTarget;
       const queryIdx = target.indexOf("?");
       if (queryIdx >= 0) {
         return {
@@ -1096,6 +1127,69 @@ const READ_ONLY_BODY_FIELDS = /* @__PURE__ */ new Set([
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function restrictBatchSubrequests(body, allowlist) {
+  const restricted = /* @__PURE__ */ new Map();
+  let changed = false;
+  let parsed = body;
+  const wasString = typeof body === "string";
+  if (wasString) {
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      return { body, restricted };
+    }
+  }
+  if (!isPlainObject(parsed) || !Array.isArray(parsed.requests)) return { body, restricted };
+  parsed.requests.forEach((request, index) => {
+    if (!isPlainObject(request) || typeof request.url !== "string") return;
+    const method = typeof request.method === "string" ? request.method.toUpperCase() : "GET";
+    const enforcement = userFieldEnforcement(request.url);
+    if (method !== "GET") return;
+    if (enforcement !== "none") {
+      const { url, fields } = restrictUserFieldUrl(request.url, allowlist, enforcement);
+      request.url = url;
+      restricted.set(String(request.id ?? index), fields);
+      changed = true;
+      logger.info(`Restricting batch subrequest ${String(request.id ?? index)} to: ${fields}`);
+    } else if (shouldStripUserFieldExpand(request.url)) {
+      const url = stripUserFieldExpandFromUrl(request.url);
+      if (url !== request.url) {
+        request.url = url;
+        changed = true;
+        logger.info(`Removing $expand from batch subrequest ${String(request.id ?? index)}`);
+      }
+    }
+  });
+  if (!changed) return { body, restricted };
+  return { body: wasString ? JSON.stringify(parsed) : parsed, restricted };
+}
+function projectBatchSubresponses(data, restricted) {
+  if (!isPlainObject(data) || !Array.isArray(data.responses)) return data;
+  return {
+    ...data,
+    responses: data.responses.map((subresponse) => {
+      if (!isPlainObject(subresponse)) return subresponse;
+      const fields = restricted.get(String(subresponse.id));
+      if (!fields) return subresponse;
+      return { ...subresponse, body: projectSelectedFields(subresponse.body, fields, true) };
+    })
+  };
+}
+function userProfilePassthroughError(target, userFields) {
+  if (userFields === void 0 || !targetsUserProfile(target)) return void 0;
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: "user_fields_restricted",
+          message: "This deployment restricts which user profile fields may be returned, and this tool returns the response bytes verbatim. Use list-users, which applies the restriction."
+        })
+      }
+    ],
+    isError: true
+  };
+}
 function hasOwn(obj, key) {
   return Object.prototype.hasOwnProperty.call(obj, key);
 }
@@ -1106,7 +1200,37 @@ function describeParamsForLog(params) {
     return `[unserializable: ${error instanceof Error ? error.name : "unknown error"}]`;
   }
 }
-async function executeGraphTool(tool, config, graphClient, params, authManager) {
+function escapeIfStringLiteral(template, names, value) {
+  const quoted = names.some((n) => template.includes(`'{${n}}'`) || template.includes(`':${n}'`));
+  return quoted ? String(value).replace(/'/g, "''") : String(value);
+}
+function rawValueAddsSegments(template, names, value) {
+  const isTail = names.some((n) => template.endsWith(`/{${n}}`) || template.endsWith(`/:${n}`));
+  return isTail ? value.includes(":") : value.includes("/");
+}
+function invalidPathParameter(message) {
+  return {
+    content: [
+      { type: "text", text: JSON.stringify({ error: "invalid_path_parameter", message }) }
+    ],
+    isError: true
+  };
+}
+function unalteredTargetError(target) {
+  if (isUnalteredGraphPath(target.split("?")[0])) return void 0;
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: 'target must not contain "." or ".." segments, a fragment or a backslash.'
+        })
+      }
+    ],
+    isError: true
+  };
+}
+async function executeGraphTool(tool, config, graphClient, params, authManager, userFields) {
   logger.info(`Tool ${tool.alias} called with params: ${describeParamsForLog(params)}`);
   if (isConfirmGateEnabled() && isDestructiveOperation(tool.method, config) && params.confirm !== true) {
     logger.warn(
@@ -1227,7 +1351,16 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
         switch (paramDef.type) {
           case "Path": {
             const shouldSkipEncoding = config?.skipEncoding?.includes(paramName) ?? false;
-            const encodedValue = shouldSkipEncoding ? paramValue : encodeURIComponent(paramValue).replace(/%3D/g, "=");
+            const names = [paramName, camelCaseParamName];
+            if (shouldSkipEncoding && rawValueAddsSegments(tool.path, names, `${paramValue}`)) {
+              return invalidPathParameter(
+                `'${paramName}' cannot add path segments to this endpoint: no "/" in a value, and no ":" in a site path.`
+              );
+            }
+            const encodedValue = shouldSkipEncoding ? paramValue : encodeURIComponent(escapeIfStringLiteral(tool.path, names, paramValue)).replace(
+              /%3D/g,
+              "="
+            );
             path2 = path2.replace(`{${paramName}}`, encodedValue).replace(`:${paramName}`, encodedValue).replace(`{${camelCaseParamName}}`, encodedValue).replace(`:${camelCaseParamName}`, encodedValue);
             break;
           }
@@ -1265,7 +1398,9 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
         body = paramValue;
         logger.info(`Set body param: ${JSON.stringify(body)}`);
       } else if (path2.includes(`:${paramName}`) || path2.includes(`{${paramName}}`) || path2.includes(`:${camelCaseParamName}`) || path2.includes(`{${camelCaseParamName}}`)) {
-        const encodedValue = encodeURIComponent(paramValue).replace(/%3D/g, "=");
+        const encodedValue = encodeURIComponent(
+          escapeIfStringLiteral(tool.path, [paramName, camelCaseParamName], paramValue)
+        ).replace(/%3D/g, "=");
         path2 = path2.replace(`{${paramName}}`, encodedValue).replace(`:${paramName}`, encodedValue).replace(`{${camelCaseParamName}}`, encodedValue).replace(`:${camelCaseParamName}`, encodedValue);
         logger.info(`Path param fallback: replaced :${camelCaseParamName} with encoded value`);
       } else if (paramName.toLowerCase() === "accept" && config?.acceptType) {
@@ -1283,6 +1418,11 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
         logger.warn(`Dropping unrecognized parameter '${paramName}' for tool ${tool.alias}`);
       }
     }
+    if (!isUnalteredGraphPath(path2)) {
+      return invalidPathParameter(
+        'A path parameter would send this request to a different endpoint. Path parameters cannot be "." or "..", or contain "/../", "?", "#" or a backslash. Percent-encode "?" and "#" that are part of a name.'
+      );
+    }
     if (isPlainObject(body) && bodyShape != null && hasOwn(bodyShape, "body") && !Object.keys(body).some((k) => k.toLowerCase() === "body")) {
       const nestedShape = bodySchemaShape(bodyShape.body);
       if (nestedShape != null) {
@@ -1364,8 +1504,26 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
       logger.info(`Setting custom Accept: ${config.acceptType}`);
     }
     const requestedSelect = parseSelectFields(queryParams["$select"]);
+    const enforcement = userFields === void 0 ? "none" : userFieldEnforcement(path2);
+    const isUserFieldBoundary = enforcement !== "none";
+    const boundaryFields = isUserFieldBoundary && userFields !== void 0 ? restrictUserFieldQuery(queryParams, userFields, enforcement) : [];
+    if (userFields !== void 0 && shouldStripUserFieldExpand(path2)) {
+      delete queryParams["$expand"];
+    }
+    if (isUserFieldBoundary) {
+      logger.info(
+        `Restricting ${tool.alias} to configured user fields (${enforcement}): ${boundaryFields}`
+      );
+    }
+    let batchRestricted = /* @__PURE__ */ new Map();
+    if (userFields !== void 0) {
+      const restrictedBatch = restrictBatchSubrequests(body, userFields);
+      body = restrictedBatch.body;
+      batchRestricted = restrictedBatch.restricted;
+    }
+    const projectionSelect = isUserFieldBoundary ? boundaryFields : requestedSelect;
     const keepFields = [
-      .../* @__PURE__ */ new Set([...requestedSelect, ...parseSelectFields(queryParams["$expand"])])
+      .../* @__PURE__ */ new Set([...projectionSelect, ...parseSelectFields(queryParams["$expand"])])
     ];
     if (Object.keys(queryParams).length > 0) {
       const queryString = Object.entries(queryParams).map(([key, value]) => `${key}=${encodeURIComponent(value).replace(/%2C/gi, ",")}`).join("&");
@@ -1430,8 +1588,9 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
       );
     }
     const mergePages = fetchAllPages && paginationEnabled;
-    const willProject = requestedSelect.length > 0 && params.excludeResponse !== true;
-    if (mergePages || willProject) {
+    const willProject = (requestedSelect.length > 0 || isUserFieldBoundary) && params.excludeResponse !== true;
+    const willProjectBatch = batchRestricted.size > 0 && params.excludeResponse !== true;
+    if (mergePages || willProject || willProjectBatch) {
       options.forceJsonOutput = true;
     }
     let response = await graphClient.graphRequest(path2, options);
@@ -1442,13 +1601,13 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
         logger.info("Skipping $select projection: body is a transport envelope, not a resource");
         return body2;
       }
-      if (!anyFieldPresent(body2, requestedSelect)) {
+      if (!isUserFieldBoundary && !anyFieldPresent(body2, projectionSelect)) {
         logger.warn(
-          `None of the requested $select fields (${requestedSelect.join(",")}) appear in the response; returning it untrimmed`
+          `None of the requested $select fields (${projectionSelect.join(",")}) appear in the response; returning it untrimmed`
         );
         return body2;
       }
-      return projectSelectedFields(body2, keepFields);
+      return projectSelectedFields(body2, keepFields, isUserFieldBoundary);
     };
     if (mergePages && response?.content?.[0]?.text) {
       let combinedResponse;
@@ -1535,6 +1694,15 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
       } catch {
       }
     }
+    if (willProjectBatch && !response?.isError && response?.content?.[0]?.text) {
+      try {
+        const parsed = JSON.parse(response.content[0].text);
+        response.content[0].text = graphClient.serialize(
+          projectBatchSubresponses(parsed, batchRestricted)
+        );
+      } catch {
+      }
+    }
     if (response?.content?.[0]?.text) {
       const responseText = response.content[0].text;
       logger.info(`Response size: ${responseText.length} characters`);
@@ -1599,7 +1767,19 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
     };
   }
 }
-function registerGraphTools(server, graphClient, readOnly = false, enabledToolsPattern, orgMode = false, authManager, multiAccount = false, accountNames = [], allowedScopesValue, httpMode = false) {
+function registerGraphTools(server, graphClient, options = {}) {
+  const {
+    readOnly = false,
+    enabledTools: enabledToolsPattern,
+    orgMode = false,
+    authManager,
+    multiAccount = false,
+    accountNames = [],
+    allowedScopes: allowedScopesValue,
+    httpMode = false,
+    userFields: userFieldsValue
+  } = options;
+  const userFields = parseUserFields(userFieldsValue);
   let enabledToolsRegex;
   if (enabledToolsPattern) {
     try {
@@ -1718,7 +1898,7 @@ function registerGraphTools(server, graphClient, readOnly = false, enabledToolsP
             // All tools call Microsoft Graph API
           }
         },
-        async (params) => executeGraphTool(tool, endpointConfig, graphClient, params, authManager)
+        async (params) => executeGraphTool(tool, endpointConfig, graphClient, params, authManager, userFields)
       );
       registeredCount++;
     } catch (error) {
@@ -1738,7 +1918,8 @@ function registerGraphTools(server, graphClient, readOnly = false, enabledToolsP
     graphClient,
     authManager,
     multiAccount,
-    accountNames
+    accountNames,
+    userFields
   };
   for (const utility of UTILITY_TOOLS) {
     if (readOnly && !utility.readOnlyHint) continue;
@@ -1859,7 +2040,19 @@ function scoreDiscoveryQuery(query, index) {
   ranked.sort((a, b) => b.score - a.score);
   return ranked;
 }
-function registerDiscoveryTools(server, graphClient, readOnly = false, orgMode = false, authManager, multiAccount = false, accountNames = [], enabledTools, allowedScopesValue, httpMode = false) {
+function registerDiscoveryTools(server, graphClient, options = {}) {
+  const {
+    readOnly = false,
+    enabledTools,
+    orgMode = false,
+    authManager,
+    multiAccount = false,
+    accountNames = [],
+    allowedScopes: allowedScopesValue,
+    httpMode = false,
+    userFields: userFieldsValue
+  } = options;
+  const userFields = parseUserFields(userFieldsValue);
   let enabledToolsRegex;
   if (enabledTools) {
     try {
@@ -1906,7 +2099,8 @@ function registerDiscoveryTools(server, graphClient, readOnly = false, orgMode =
     graphClient,
     authManager,
     multiAccount,
-    accountNames
+    accountNames,
+    userFields
   };
   const utilityByName = new Map(utilityTools.map((u) => [u.name, u]));
   const categoryNames = Object.keys(TOOL_CATEGORIES).join(", ");
@@ -2047,7 +2241,8 @@ function registerDiscoveryTools(server, graphClient, readOnly = false, orgMode =
           toolData.config,
           graphClient,
           parameters,
-          authManager
+          authManager,
+          userFields
         );
       }
       const utility = utilityByName.get(tool_name);

package/dist/lib/attachment-tickets.js

@@ -24,6 +24,15 @@ function isPlainGraphPath(target) {
   }
   return resolved.origin === PROBE_ORIGIN && resolved.search === "" && resolved.hash === "" && resolved.pathname === PROBE_PREFIX + target;
 }
+function isUnalteredGraphPath(path) {
+  const decode = (s) => decodeURIComponent(s.replace(/%(?![0-9a-f]{2})/gi, "%25"));
+  try {
+    const resolved = new URL(PROBE_ORIGIN + PROBE_PREFIX + path);
+    return resolved.origin === PROBE_ORIGIN && resolved.search === "" && resolved.hash === "" && decode(resolved.pathname) === decode(PROBE_PREFIX + path);
+  } catch {
+    return false;
+  }
+}
 const MAX_LIVE_TICKETS = 256;
 const TICKET_BYTES = 32;
 class TicketStoreFullError extends Error {
@@ -94,5 +103,6 @@ export {
   TICKET_PARAM,
   TicketStoreFullError,
   buildAttachmentUrl,
-  isPlainGraphPath
+  isPlainGraphPath,
+  isUnalteredGraphPath
 };

package/dist/lib/select-projection.js

@@ -23,8 +23,9 @@ function parseSelectFields(value) {
     )
   ];
 }
-function isAlwaysKept(key) {
-  return key.toLowerCase() === "id" || key.startsWith("@") || key.startsWith("_");
+function isAlwaysKept(key, strict = false) {
+  if (key.startsWith("@") || key.startsWith("_")) return true;
+  return !strict && key.toLowerCase() === "id";
 }
 const TRANSPORT_OK_MESSAGE = "OK!";
 function isTransportEnvelope(data) {
@@ -50,28 +51,28 @@ function anyFieldPresent(data, fields) {
   if (objects.length === 0) return true;
   return objects.some((item) => Object.keys(item).some((key) => wanted.has(key.toLowerCase())));
 }
-function projectObject(item, wanted) {
+function projectObject(item, wanted, strict) {
   if (!isPlainObject(item)) return item;
   const projected = {};
   for (const [key, value] of Object.entries(item)) {
-    if (isAlwaysKept(key) || wanted.has(key.toLowerCase())) {
+    if (isAlwaysKept(key, strict) || wanted.has(key.toLowerCase())) {
       projected[key] = value;
     }
   }
   return projected;
 }
-function projectSelectedFields(data, fields) {
+function projectSelectedFields(data, fields, strict = false) {
   if (fields.length === 0) return data;
   if (!data || typeof data !== "object") return data;
   const wanted = new Set(fields.map((field) => field.toLowerCase()));
   if (Array.isArray(data)) {
-    return data.map((item) => projectObject(item, wanted));
+    return data.map((item) => projectObject(item, wanted, strict));
   }
   const body = data;
   if (Array.isArray(body.value)) {
-    return { ...body, value: body.value.map((item) => projectObject(item, wanted)) };
+    return { ...body, value: body.value.map((item) => projectObject(item, wanted, strict)) };
   }
-  return projectObject(body, wanted);
+  return projectObject(body, wanted, strict);
 }
 export {
   TRANSPORT_OK_MESSAGE,

package/dist/lib/user-field-policy.js

@@ -0,0 +1,69 @@
+import { parseSelectFields } from "./select-projection.js";
+const USER_ENTITY_PATH = /^\/users(?:\/[^/]+)?\/?$/i;
+const DIRECTORY_NAVIGATION_PATH = /^(?:\/me|\/users\/[^/]+)\/(?:manager|directReports)\/?$|^\/groups\/[^/]+\/(?:members|owners)\/?$/i;
+const EXPAND_USER_PATH = /^\/me\/?$|^\/groups(?:\/[^/]+)?\/?$/i;
+function normalizePath(path) {
+  const withoutQuery = path.split("?")[0];
+  return withoutQuery.startsWith("/") ? withoutQuery : `/${withoutQuery}`;
+}
+function userFieldEnforcement(path) {
+  const normalized = normalizePath(path);
+  if (USER_ENTITY_PATH.test(normalized)) return "request-and-response";
+  if (DIRECTORY_NAVIGATION_PATH.test(normalized)) return "response-only";
+  return "none";
+}
+function targetsUserProfile(path) {
+  return userFieldEnforcement(path) !== "none";
+}
+function shouldStripUserFieldExpand(path) {
+  const normalized = normalizePath(path);
+  return userFieldEnforcement(normalized) !== "none" || EXPAND_USER_PATH.test(normalized);
+}
+function stripUserFieldExpandFromUrl(url) {
+  const [path, query = ""] = url.split("?");
+  if (!shouldStripUserFieldExpand(path) || query === "") return url;
+  const params = new URLSearchParams(query);
+  if (!params.has("$expand")) return url;
+  params.delete("$expand");
+  const rebuilt = params.toString();
+  if (rebuilt === "") return path;
+  return `${path}?${rebuilt.replace(/%24/gi, "$").replace(/%2C/gi, ",")}`;
+}
+function effectiveUserFields(requestedSelect, allowlist) {
+  const allowed = requestedSelect.filter(
+    (field) => allowlist.some((entry) => entry.toLowerCase() === field.toLowerCase())
+  );
+  return allowed.length > 0 ? allowed : allowlist;
+}
+function restrictUserFieldQuery(queryParams, allowlist, enforcement) {
+  const fields = effectiveUserFields(parseSelectFields(queryParams["$select"]), allowlist);
+  if (enforcement === "request-and-response") {
+    queryParams["$select"] = fields.join(",");
+  }
+  delete queryParams["$expand"];
+  return fields;
+}
+function restrictUserFieldUrl(url, allowlist, enforcement) {
+  const [path, query = ""] = url.split("?");
+  const params = new URLSearchParams(query);
+  const fields = effectiveUserFields(
+    parseSelectFields(params.get("$select") ?? void 0),
+    allowlist
+  );
+  if (enforcement === "request-and-response") {
+    params.set("$select", fields.join(","));
+  }
+  params.delete("$expand");
+  const rebuilt = params.toString();
+  if (rebuilt === "") return { url: path, fields };
+  return { url: `${path}?${rebuilt.replace(/%24/gi, "$").replace(/%2C/gi, ",")}`, fields };
+}
+export {
+  effectiveUserFields,
+  restrictUserFieldQuery,
+  restrictUserFieldUrl,
+  shouldStripUserFieldExpand,
+  stripUserFieldExpandFromUrl,
+  targetsUserProfile,
+  userFieldEnforcement
+};