@littlebearapps/outlook-assistant 3.7.1 → 3.7.4

package/settings/index.js

@@ -227,12 +227,27 @@ async function handleSetAutomaticReplies(args) {
 
     // Build the settings object
     const settings = {};
+    let requestedStatus = null;
 
     // Determine status
     if (enabled === false) {
       settings.status = 'disabled';
+      requestedStatus = 'disabled';
+      // F-6: Graph keeps schedule timestamps when transitioning out of
+      // 'scheduled' mode unless they're explicitly cleared, which leaves
+      // status stuck at 'scheduled'. Reset both to the unix epoch so the
+      // disable actually applies. Graph rejects null here.
+      settings.scheduledStartDateTime = {
+        dateTime: '1970-01-01T00:00:00.000',
+        timeZone: 'UTC',
+      };
+      settings.scheduledEndDateTime = {
+        dateTime: '1970-01-01T00:00:00.000',
+        timeZone: 'UTC',
+      };
     } else if (startDateTime && endDateTime) {
       settings.status = 'scheduled';
+      requestedStatus = 'scheduled';
       settings.scheduledStartDateTime = {
         dateTime: new Date(startDateTime).toISOString(),
         timeZone: 'UTC',
@@ -243,6 +258,7 @@ async function handleSetAutomaticReplies(args) {
       };
     } else if (enabled === true) {
       settings.status = 'alwaysEnabled';
+      requestedStatus = 'alwaysEnabled';
     }
 
     // Reply messages
@@ -269,6 +285,21 @@ async function handleSetAutomaticReplies(args) {
       settings.externalAudience = externalAudience;
     }
 
+    // F-4: refuse to claim "updated" when nothing meaningful changed.
+    // Catches the misleading-success case where the caller passed only
+    // externalAudience without enabled/scheduled — previously the wrapper
+    // announced "Automatic replies updated!" with no actual state change.
+    if (Object.keys(settings).length === 0) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'No automatic-reply settings were provided. To change state, pass `enabled: true|false` or `startDateTime` + `endDateTime`. To update messages or audience, pass `internalReplyMessage`, `externalReplyMessage`, or `externalAudience`.',
+          },
+        ],
+      };
+    }
+
     // Apply settings
     await callGraphAPI(accessToken, 'PATCH', 'me/mailboxSettings', {
       automaticRepliesSetting: settings,
@@ -282,9 +313,37 @@ async function handleSetAutomaticReplies(args) {
     );
 
     const output = [];
-    output.push('Automatic replies updated!\n');
+    if (requestedStatus) {
+      output.push('Automatic replies updated!\n');
+    } else {
+      // F-4: no status-changing param was provided. Spell out exactly
+      // which fields the PATCH carried so the caller doesn't think
+      // the status flipped silently.
+      const otherFields = Object.keys(settings).join(', ');
+      output.push(
+        `Updated automatic-reply settings (${otherFields}). No status change applied — pass \`enabled\` or \`startDateTime\`+\`endDateTime\` to change state.\n`
+      );
+    }
     output.push(formatAutomaticReplies(updated));
 
+    // F-7: Graph silently coerces alwaysEnabled → disabled on personal
+    // Outlook.com accounts (no error returned). Detect divergence
+    // between requested and post-PATCH state and surface it to the
+    // caller so they can correct the call.
+    if (requestedStatus && updated.status !== requestedStatus) {
+      let hint = '';
+      if (
+        requestedStatus === 'alwaysEnabled' &&
+        updated.status === 'disabled'
+      ) {
+        hint =
+          ' Personal Outlook.com accounts only support `scheduled` mode — provide `startDateTime` + `endDateTime` instead of `enabled: true` alone.';
+      }
+      output.push(
+        `\n**⚠ Warning**: Requested status \`${requestedStatus}\` but Graph applied \`${updated.status}\`.${hint}`
+      );
+    }
+
     // Warn if enabling without messages
     if (
       updated.status !== 'disabled' &&
@@ -641,6 +700,7 @@ const settingsTools = [
             "Time zone name, e.g. 'Australia/Melbourne' (action=set-working-hours)",
         },
       },
+      additionalProperties: false,
       required: [],
     },
     handler: async (args) => {
@@ -651,8 +711,16 @@ const settingsTools = [
         case 'set-working-hours':
           return handleSetWorkingHours(args);
         case 'get':
-        default:
           return handleGetMailboxSettings(args);
+        default:
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `Unknown action '${action}'. Valid actions: get, set-auto-replies, set-working-hours.`,
+              },
+            ],
+          };
       }
     },
   },

package/utils/response-formatter.js

@@ -261,6 +261,11 @@ function formatEmailContent(
     body = email.bodyPreview || 'No content';
   }
 
+  // F-16: strip tracking-pixel zero-width chars before returning. These
+  // serve no purpose for AI consumption and can run into the hundreds
+  // per message, bloating token usage.
+  body = stripZeroWidth(body);
+
   // Truncate if needed (unless full verbosity requested)
   if (verbosity !== VERBOSITY.FULL) {
     const truncated = truncateWithMeta(body, DEFAULT_LIMITS.maxBodyTruncation);
@@ -480,6 +485,27 @@ function stripHtml(html) {
     .trim();
 }
 
+/**
+ * Strip zero-width characters and their HTML entity equivalents
+ * (F-16). Mailers inject hundreds of these to defeat Gmail clipping
+ * and threading; they bloat token usage and confuse AI consumers
+ * without adding any signal. Removes:
+ *
+ *   - U+200B..U+200F (zero-width space, joiner, non-joiner, RTL/LTR
+ *     marks)
+ *   - U+FEFF (BOM)
+ *   - U+2060 (word joiner)
+ *   - HTML decimal entities: ​..‏, ⁠, 
+ *   - HTML named entities: ‍, ‌, ‎, ‏
+ */
+function stripZeroWidth(text) {
+  if (!text) return text;
+  return text
+    .replace(/[\u200B-\u200F\u2060\uFEFF]+/g, '')
+    .replace(/&#(8203|8204|8205|8206|8207|8288|65279);/g, '')
+    .replace(/&(zwj|zwnj|lrm|rlm);/g, '');
+}
+
 function escapeCSV(value) {
   if (value === null || value === undefined) return '';
   const str = String(value);
@@ -520,5 +546,6 @@ module.exports = {
   formatRecipients,
   truncateText,
   stripHtml,
+  stripZeroWidth,
   escapeCSV,
 };

package/utils/schema-coerce.js

@@ -0,0 +1,248 @@
+/**
+ * MCP boundary schema coercion + validation.
+ *
+ * Some MCP clients deliver array/boolean/number params as strings (the
+ * JSON-RPC marshalling differs across clients). Handlers were written
+ * assuming JS-typed values, so these arrive broken — arrays iterate
+ * character-by-character, `=== true` fails on `'true'`, etc.
+ *
+ * This module walks each tool's `inputSchema.properties` once at the
+ * MCP entry point and coerces incoming values into the declared types.
+ * It also enforces `additionalProperties: false`, top-level enum
+ * constraints, and `required`. Anything that fails coercion or
+ * validation gets surfaced as an MCP error response before the
+ * handler is invoked.
+ *
+ * Tracks GH #160 (param-shape mismatches) and #162 (unknown-action
+ * fallthrough — enums caught here instead of in switch defaults).
+ */
+
+class CoercionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CoercionError';
+  }
+}
+
+/**
+ * Coerce a single value against a JSON schema fragment. Mutates nothing.
+ * Throws CoercionError on type mismatch that can't be resolved.
+ */
+function coerceValue(value, schema, path) {
+  if (value === undefined || value === null) return value;
+  if (!schema || !schema.type) return value;
+
+  const type = schema.type;
+
+  if (type === 'array') {
+    let arr = value;
+    if (typeof arr === 'string') {
+      try {
+        arr = JSON.parse(arr);
+      } catch (_e) {
+        throw new CoercionError(
+          `${path}: expected array, got non-JSON string "${truncate(value)}"`
+        );
+      }
+    }
+    if (!Array.isArray(arr)) {
+      throw new CoercionError(
+        `${path}: expected array, got ${describeType(arr)}`
+      );
+    }
+    if (schema.items) {
+      return arr.map((item, i) =>
+        coerceValue(item, schema.items, `${path}[${i}]`)
+      );
+    }
+    return arr;
+  }
+
+  if (type === 'boolean') {
+    if (typeof value === 'boolean') return value;
+    if (value === 'true' || value === 1 || value === '1') return true;
+    if (value === 'false' || value === 0 || value === '0') return false;
+    throw new CoercionError(
+      `${path}: expected boolean, got ${describeType(value)} (${truncate(JSON.stringify(value))})`
+    );
+  }
+
+  if (type === 'integer') {
+    if (typeof value === 'number' && Number.isInteger(value)) return value;
+    if (typeof value === 'string' && value.trim() !== '') {
+      const n = Number(value);
+      if (Number.isInteger(n)) return n;
+    }
+    throw new CoercionError(
+      `${path}: expected integer, got ${describeType(value)} (${truncate(JSON.stringify(value))})`
+    );
+  }
+
+  if (type === 'number') {
+    if (typeof value === 'number') return value;
+    if (typeof value === 'string' && value.trim() !== '') {
+      const n = Number(value);
+      if (!Number.isNaN(n)) return n;
+    }
+    throw new CoercionError(
+      `${path}: expected number, got ${describeType(value)} (${truncate(JSON.stringify(value))})`
+    );
+  }
+
+  if (type === 'object') {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+      throw new CoercionError(
+        `${path}: expected object, got ${describeType(value)}`
+      );
+    }
+    if (!schema.properties) return value;
+    const result = { ...value };
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if (key in value) {
+        result[key] = coerceValue(value[key], propSchema, `${path}.${key}`);
+      }
+    }
+    return result;
+  }
+
+  if (type === 'string') {
+    // F-24: reject arrays passed to string-typed params with a clear
+    // hint. The chokepoint pattern coerces arrays *into* arrays
+    // (F-25/F-33/F-36) but quietly let arrays slip through to string
+    // params, where they got JSON-stringified and rejected by Graph
+    // with a confusing 400. Tools whose schema declares a comma-
+    // separated string for `to`/`cc`/etc. now surface a friendly
+    // MCP-layer error before the call ever leaves the process.
+    if (Array.isArray(value)) {
+      throw new CoercionError(
+        `${path}: expected comma-separated string, got array — pass "a@example.com,b@example.com" instead of ["a@example.com","b@example.com"]`
+      );
+    }
+    // F-24 part 2 (#168): some MCP clients JSON-stringify array literals
+    // before transmission when the schema declares type:string, so the
+    // array arrives here as the literal string '["a@x.com","b@x.com"]'
+    // (brackets and quotes intact). Array.isArray returns false; the
+    // value would otherwise pass through and Graph would reject the
+    // literal-bracket address with a confusing 400.
+    if (typeof value === 'string') {
+      const trimmed = value.trim();
+      if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        let parsed;
+        try {
+          parsed = JSON.parse(trimmed);
+        } catch (_e) {
+          parsed = undefined;
+        }
+        if (Array.isArray(parsed)) {
+          const hint = parsed.every((p) => typeof p === 'string')
+            ? `"${parsed.join(',')}"`
+            : 'a comma-separated string';
+          throw new CoercionError(
+            `${path}: expected comma-separated string, got JSON-encoded array — pass ${hint} instead of ${trimmed}`
+          );
+        }
+      }
+    }
+    return value;
+  }
+
+  // unknown type: pass through
+  return value;
+}
+
+/**
+ * Coerce + validate args against a tool's inputSchema. Returns
+ *   { args: <coerced> } on success, or
+ *   { error: '<message>' } on failure.
+ *
+ * Validates (in this order, all errors collected):
+ *   1. additionalProperties: false (rejects unknown params)
+ *   2. type coercion for each declared property (string→array/boolean/number)
+ *   3. required (rejects missing required params)
+ *   4. enum on top-level properties (rejects out-of-enum values)
+ */
+function coerceArgsAgainstSchema(args, inputSchema) {
+  if (!inputSchema || !inputSchema.properties) return { args: args || {} };
+  const safeArgs = args || {};
+  const errors = [];
+
+  // 1. additionalProperties: false
+  if (inputSchema.additionalProperties === false) {
+    const known = new Set(Object.keys(inputSchema.properties));
+    const unknown = Object.keys(safeArgs).filter((k) => !known.has(k));
+    if (unknown.length > 0) {
+      const validList = [...known].sort().join(', ');
+      errors.push(
+        `Unknown parameter${unknown.length > 1 ? 's' : ''}: ${unknown
+          .map((k) => `'${k}'`)
+          .join(', ')}. Valid parameters: ${validList}.`
+      );
+    }
+  }
+
+  // 2. coerce each known property
+  const coerced = { ...safeArgs };
+  for (const [key, propSchema] of Object.entries(inputSchema.properties)) {
+    if (!(key in safeArgs)) continue;
+    try {
+      coerced[key] = coerceValue(safeArgs[key], propSchema, key);
+    } catch (e) {
+      if (e instanceof CoercionError) {
+        errors.push(e.message);
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  // 3. required
+  if (Array.isArray(inputSchema.required)) {
+    for (const key of inputSchema.required) {
+      if (
+        !(key in safeArgs) ||
+        safeArgs[key] === undefined ||
+        safeArgs[key] === null ||
+        safeArgs[key] === ''
+      ) {
+        errors.push(`Required parameter '${key}' is missing.`);
+      }
+    }
+  }
+
+  // 4. top-level enum constraints
+  for (const [key, propSchema] of Object.entries(inputSchema.properties)) {
+    if (!(key in coerced)) continue;
+    if (!Array.isArray(propSchema.enum)) continue;
+    const v = coerced[key];
+    if (v === undefined || v === null) continue;
+    if (!propSchema.enum.includes(v)) {
+      errors.push(
+        `Parameter '${key}': value '${v}' not in allowed values [${propSchema.enum
+          .map((x) => `'${x}'`)
+          .join(', ')}].`
+      );
+    }
+  }
+
+  if (errors.length > 0) {
+    return { error: errors.join('\n') };
+  }
+  return { args: coerced };
+}
+
+function describeType(value) {
+  if (value === null) return 'null';
+  if (Array.isArray(value)) return 'array';
+  return typeof value;
+}
+
+function truncate(s, n = 60) {
+  if (typeof s !== 'string') s = String(s);
+  return s.length > n ? `${s.slice(0, n)}…` : s;
+}
+
+module.exports = {
+  coerceArgsAgainstSchema,
+  coerceValue,
+  CoercionError,
+};