outlook-cli 1.2.2 → 1.2.3

package/CLI.md

@@ -56,6 +56,8 @@ outlook-cli call list-emails --args-json '{"folder":"inbox","count":5}' --ai
 outlook-cli email list --folder inbox --count 20
 outlook-cli email search --query "invoice" --unread-only true --count 10
 outlook-cli email read --id <message-id>
+outlook-cli email attachments --id <message-id>
+outlook-cli email attachment --id <message-id> --attachment-id <attachment-id> --save-path ./downloads/
 outlook-cli email send --to jane@example.com --subject "Status" --body "Done"
 outlook-cli email mark-read --id <message-id> --is-read true
 ```

package/README.md

@@ -11,7 +11,7 @@ Production-ready CLI and MCP server for Microsoft Outlook through Microsoft Grap
 - Global CLI command: `outlook-cli`
 - One-time OAuth token storage — reused across runs and updates
 - Human-friendly commands with rich terminal output, theme presets, and machine-friendly `--json`/`--ai` mode
-- 19 MCP tools available to Claude and other AI assistants via the shared tool registry
+- 21 MCP tools available to Claude and other AI assistants via the shared tool registry
 - Full email, calendar, folder, and rules management through Microsoft Graph API
 
 ---
@@ -181,6 +181,8 @@ outlook-cli auth server --status
 | `email list` | List recent emails | `outlook-cli email list --count 20` |
 | `email search` | Search emails by criteria | `outlook-cli email search --from boss@company.com` |
 | `email read` | Read full email content | `outlook-cli email read --id AAMkAGVm...` |
+| `email attachments` | List attachments on one email | `outlook-cli email attachments --id AAMkAGVm...` |
+| `email attachment` | Get one attachment and optionally save it | `outlook-cli email attachment --id AAMkAGVm... --attachment-id AA... --save-path ./downloads/` |
 | `email send` | Send a new email | `outlook-cli email send --to user@example.com --subject "Hi" --body "Hello"` |
 | `email mark-read` | Mark email as read or unread | `outlook-cli email mark-read --id AAMkAGVm...` |
 
@@ -284,6 +286,70 @@ outlook-cli email read --id AAMkAGVmMDAwAT... --json
 
 ---
 
+#### `email attachments` — List Email Attachments
+
+Lists attachments for a specific email message.
+
+**Parameters:**
+
+| Flag | Type | Required | Default | Description |
+|---|---|---|---|---|
+| `--id` | string | yes | — | Message ID from `email list` or `email search` |
+| `--count` | number | no | `25` | Max attachments to list (1–50) |
+
+**Examples:**
+```bash
+# List attachments for one message
+outlook-cli email attachments --id AAMkAGVmMDAwAT...
+
+# Limit to first 10 attachments
+outlook-cli email attachments --id AAMkAGVmMDAwAT... --count 10
+```
+
+**Output shows:** Attachment ID, type (`fileAttachment`, `itemAttachment`, or `referenceAttachment`), content type, size, inline flag, and last modified date.
+
+---
+
+#### `email attachment` — Get/Download One Attachment
+
+Gets metadata for one attachment and optionally saves it to disk.
+
+**Parameters:**
+
+| Flag | Type | Required | Default | Description |
+|---|---|---|---|---|
+| `--id` | string | yes | — | Message ID |
+| `--attachmentId` | string | yes | — | Attachment ID from `email attachments` |
+| `--savePath` | string | no | — | File path or directory path to save downloaded bytes |
+| `--includeContent` | boolean | no | `false` | Include text preview when attachment content is text-like |
+| `--expandItem` | boolean | no | `false` | Expand metadata for item attachments |
+| `--overwrite` | boolean | no | `false` | Overwrite existing file at destination path |
+
+**Examples:**
+```bash
+# Get metadata only
+outlook-cli email attachment --id AAMkAGVmMDAwAT... --attachment-id AAMkAGVmMDAwAT...=
+
+# Save attachment to downloads directory
+outlook-cli email attachment \
+  --id AAMkAGVmMDAwAT... \
+  --attachment-id AAMkAGVmMDAwAT...= \
+  --save-path ./downloads/
+
+# Save and include text preview when possible
+outlook-cli email attachment \
+  --id AAMkAGVmMDAwAT... \
+  --attachment-id AAMkAGVmMDAwAT...= \
+  --save-path ./downloads/ \
+  --include-content
+```
+
+**Notes:**
+- `referenceAttachment` is a cloud link and cannot be downloaded as raw bytes from this endpoint.
+- Item attachments use MIME raw content when downloaded.
+
+---
+
 #### `email send` — Send Email
 
 Composes and sends an email from the user's account.
@@ -326,7 +392,7 @@ outlook-cli email send \
 
 **Notes:**
 - HTML body is detected automatically when the body contains `<html`.
-- Attachments are not supported — body text only.
+- Sending attachments is not supported yet — body text only.
 
 ---
 
@@ -836,7 +902,7 @@ outlook-cli calendar list --plain
 
 ## Complete MCP Tool Catalog
 
-All 19 tools are available through the shared MCP tool registry — used by Claude and other AI assistants, and also callable via `outlook-cli call <tool-name>`.
+All 21 tools are available through the shared MCP tool registry — used by Claude and other AI assistants, and also callable via `outlook-cli call <tool-name>`.
 
 ### Authentication Tools
 
@@ -863,6 +929,8 @@ All 19 tools are available through the shared MCP tool registry — used by Clau
 | `list-emails` | List recent emails from a folder | none | `folder`, `count` |
 | `search-emails` | Search with text and filter criteria | none | `query`, `folder`, `from`, `to`, `subject`, `hasAttachments`, `unreadOnly`, `count` |
 | `read-email` | Read full content of one email | `id` | none |
+| `list-attachments` | List attachments on a message | `messageId` | `count` |
+| `get-attachment` | Get one attachment metadata and optionally download it | `messageId`, `attachmentId` | `savePath`, `includeContent`, `expandItem`, `overwrite` |
 | `send-email` | Send a new email | `to`, `subject`, `body` | `cc`, `bcc`, `importance`, `saveToSentItems` |
 | `mark-as-read` | Mark email read or unread | `id` | `isRead` (boolean, default `true`) |
 
@@ -999,7 +1067,7 @@ uv run python tools/install_skill.py --verify --personal
 |---|---|
 | [skills/outlook-automation/SKILL.md](skills/outlook-automation/SKILL.md) | Main skill entry — overview, behavioral rules, quick examples, install instructions |
 | [skills/outlook-automation/reference/cli.md](skills/outlook-automation/reference/cli.md) | Complete CLI command reference — every command, flag, and example |
-| [skills/outlook-automation/reference/json-schema.md](skills/outlook-automation/reference/json-schema.md) | JSON schemas for all 19 MCP tools |
+| [skills/outlook-automation/reference/json-schema.md](skills/outlook-automation/reference/json-schema.md) | JSON schemas for all 21 MCP tools |
 | [skills/outlook-automation/reference/security.md](skills/outlook-automation/reference/security.md) | OAuth flow, token lifecycle, permission scopes, AI safety rules |
 | [skills/outlook-automation/reference/troubleshooting.md](skills/outlook-automation/reference/troubleshooting.md) | Common errors, diagnostic checklist, step-by-step fixes |
 

package/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * Production-oriented local CLI for outlook-cli.
  *
@@ -767,7 +767,7 @@ function printUsage() {
     formatRow('mcp-server', 'Run stdio MCP server (for Claude/Codex/VS Code)'),
     '',
     tone('Command groups', 'section'),
-    formatRow('email', 'list|search|read|send|mark-read'),
+    formatRow('email', 'list|search|read|attachments|attachment|send|mark-read'),
     formatRow('calendar', 'list|create|decline|cancel|delete'),
     formatRow('folder', 'list|create|move'),
     formatRow('rule', 'list|create|sequence'),
@@ -775,6 +775,8 @@ function printUsage() {
     tone('Examples', 'section'),
     `  ${cliCommand('auth login --open --start-server --wait --timeout 180')}`,
     `  ${cliCommand('auth login --open --client-id <id> --client-secret <secret>')}`,
+    `  ${cliCommand('email attachments --id <message-id>')}`,
+    `  ${cliCommand('email attachment --id <message-id> --attachment-id <attachment-id> --save-path ./downloads/')}`,
     `  ${cliCommand('agents guide --json')}`,
     `  ${cliCommand("call list-emails --args-json '{\"folder\":\"inbox\",\"count\":5}' --ai")}`,
     `  ${cliCommand('tools schema send-email')}`,
@@ -867,7 +869,7 @@ function buildCommandCatalog() {
   return {
     commandGroups: {
       auth: ['status', 'url', 'login', 'logout', 'server'],
-      email: ['list', 'search', 'read', 'send', 'mark-read'],
+      email: ['list', 'search', 'read', 'attachments', 'attachment', 'send', 'mark-read'],
       calendar: ['list', 'create', 'decline', 'cancel', 'delete'],
       folder: ['list', 'create', 'move'],
       rule: ['list', 'create', 'sequence'],
@@ -1401,6 +1403,36 @@ async function handleEmailCommand(action, options, outputMode) {
       return;
     }
 
+    case 'attachments': {
+      await callTool(
+        'list-attachments',
+        {
+          messageId: requireOption(options, 'id', `Usage: ${cliCommand('email attachments --id <email-id> [--count <number>]')}`),
+          count: asNumber(readOption(options, 'count', 25), 25, 'count')
+        },
+        outputMode,
+        'email attachments'
+      );
+      return;
+    }
+
+    case 'attachment': {
+      await callTool(
+        'get-attachment',
+        {
+          messageId: requireOption(options, 'id', `Usage: ${cliCommand('email attachment --id <email-id> --attachment-id <attachment-id> [--save-path <path>]')}`),
+          attachmentId: requireOption(options, 'attachmentId', `Usage: ${cliCommand('email attachment --id <email-id> --attachment-id <attachment-id> [--save-path <path>]')}`),
+          savePath: readOption(options, 'savePath', readOption(options, 'out')),
+          includeContent: asBoolean(readOption(options, 'includeContent', false), false),
+          expandItem: asBoolean(readOption(options, 'expandItem', false), false),
+          overwrite: asBoolean(readOption(options, 'overwrite', false), false)
+        },
+        outputMode,
+        'email attachment'
+      );
+      return;
+    }
+
     case 'send': {
       await callTool(
         'send-email',
@@ -1433,7 +1465,7 @@ async function handleEmailCommand(action, options, outputMode) {
     }
 
     default:
-      throw new UsageError('Unknown email command. Use: email list|search|read|send|mark-read');
+      throw new UsageError('Unknown email command. Use: email list|search|read|attachments|attachment|send|mark-read');
   }
 }
 

package/email/attachments.js

@@ -0,0 +1,359 @@
+/**
+ * Email attachment listing and retrieval functionality
+ */
+const fs = require('fs');
+const path = require('path');
+const { callGraphAPI, callGraphAPIRaw } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+
+const DEFAULT_ATTACHMENT_COUNT = 25;
+const MAX_ATTACHMENT_COUNT = 50;
+
+function textResponse(text) {
+  return {
+    content: [{
+      type: 'text',
+      text
+    }]
+  };
+}
+
+function asBoolean(value, defaultValue = false) {
+  if (value === undefined || value === null || value === '') {
+    return defaultValue;
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return value !== 0;
+  }
+
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) {
+    return true;
+  }
+
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) {
+    return false;
+  }
+
+  return defaultValue;
+}
+
+function asCount(value, defaultValue = DEFAULT_ATTACHMENT_COUNT) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return defaultValue;
+  }
+
+  return Math.min(parsed, MAX_ATTACHMENT_COUNT);
+}
+
+function getAttachmentKind(rawType) {
+  const type = String(rawType || '').toLowerCase();
+
+  if (type.includes('fileattachment')) {
+    return 'fileAttachment';
+  }
+
+  if (type.includes('itemattachment')) {
+    return 'itemAttachment';
+  }
+
+  if (type.includes('referenceattachment')) {
+    return 'referenceAttachment';
+  }
+
+  return 'attachment';
+}
+
+function sanitizeFileName(value) {
+  const raw = String(value || '').trim();
+  if (!raw) {
+    return 'attachment.bin';
+  }
+
+  const sanitized = raw
+    .replace(/[<>:"/\\|?*\u0000-\u001F]/g, '_')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  return sanitized || 'attachment.bin';
+}
+
+function shouldTreatAsDirectory(inputPath) {
+  const value = String(inputPath || '');
+  return value.endsWith(path.sep) || value.endsWith('/') || value.endsWith('\\');
+}
+
+function resolveOutputFilePath(savePath, fallbackFileName) {
+  const requested = String(savePath || '').trim();
+  if (!requested) {
+    return '';
+  }
+
+  const resolved = path.resolve(requested);
+  if (fs.existsSync(resolved)) {
+    const stats = fs.statSync(resolved);
+    if (stats.isDirectory()) {
+      return path.join(resolved, fallbackFileName);
+    }
+
+    return resolved;
+  }
+
+  if (shouldTreatAsDirectory(requested)) {
+    return path.join(resolved, fallbackFileName);
+  }
+
+  return resolved;
+}
+
+function ensureOutputWritable(filePath, overwrite) {
+  if (fs.existsSync(filePath) && !overwrite) {
+    throw new Error(`File already exists at ${filePath}. Re-run with overwrite=true to replace it.`);
+  }
+
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function looksLikeText(buffer) {
+  if (!buffer || buffer.length === 0) {
+    return false;
+  }
+
+  const sampleSize = Math.min(buffer.length, 2048);
+  let printableCount = 0;
+
+  for (let index = 0; index < sampleSize; index += 1) {
+    const byte = buffer[index];
+    const isPrintable = byte === 9 || byte === 10 || byte === 13 || (byte >= 32 && byte <= 126);
+    if (isPrintable) {
+      printableCount += 1;
+    }
+  }
+
+  return (printableCount / sampleSize) >= 0.8;
+}
+
+function buildContentPreview(buffer) {
+  if (!looksLikeText(buffer)) {
+    return '';
+  }
+
+  return buffer
+    .toString('utf8', 0, Math.min(buffer.length, 4096))
+    .slice(0, 600)
+    .trim();
+}
+
+function defaultFileName(attachment, attachmentId) {
+  const kind = getAttachmentKind(attachment['@odata.type']);
+  const fromName = sanitizeFileName(attachment.name || '');
+
+  if (fromName !== 'attachment.bin') {
+    if (kind === 'itemAttachment' && !path.extname(fromName)) {
+      return `${fromName}.eml`;
+    }
+
+    return fromName;
+  }
+
+  if (kind === 'itemAttachment') {
+    return `attachment-${attachmentId}.eml`;
+  }
+
+  return `attachment-${attachmentId}.bin`;
+}
+
+async function getAttachmentBytes(accessToken, messageId, attachment, attachmentId) {
+  const kind = getAttachmentKind(attachment['@odata.type']);
+
+  if (kind === 'referenceAttachment') {
+    throw new Error('Reference attachments are cloud links and cannot be downloaded as raw bytes via this endpoint.');
+  }
+
+  if (kind === 'fileAttachment' && attachment.contentBytes) {
+    return Buffer.from(attachment.contentBytes, 'base64');
+  }
+
+  const rawResponse = await callGraphAPIRaw(
+    accessToken,
+    'GET',
+    `me/messages/${messageId}/attachments/${attachmentId}/$value`
+  );
+
+  return rawResponse.body;
+}
+
+function formatAttachmentLine(attachment, index) {
+  const type = getAttachmentKind(attachment['@odata.type']);
+  const modified = attachment.lastModifiedDateTime
+    ? new Date(attachment.lastModifiedDateTime).toLocaleString()
+    : 'Unknown';
+
+  return `${index + 1}. ${attachment.name || '(unnamed attachment)'}
+ID: ${attachment.id}
+Type: ${type}
+Content Type: ${attachment.contentType || 'unknown'}
+Size: ${attachment.size || 0} bytes
+Inline: ${attachment.isInline ? 'Yes' : 'No'}
+Last Modified: ${modified}`;
+}
+
+/**
+ * List attachments for an email message
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleListAttachments(args = {}) {
+  const messageId = args.messageId || args.id;
+  const count = asCount(args.count, DEFAULT_ATTACHMENT_COUNT);
+
+  if (!messageId) {
+    return textResponse('Message ID is required.');
+  }
+
+  try {
+    const accessToken = await ensureAuthenticated();
+
+    const response = await callGraphAPI(
+      accessToken,
+      'GET',
+      `me/messages/${messageId}/attachments`,
+      null,
+      {
+        $top: count,
+        $select: 'id,name,contentType,size,isInline,lastModifiedDateTime'
+      }
+    );
+
+    const attachments = Array.isArray(response.value) ? response.value : [];
+
+    if (attachments.length === 0) {
+      return textResponse(`No attachments found for message ${messageId}.`);
+    }
+
+    const formatted = attachments
+      .map((attachment, index) => formatAttachmentLine(attachment, index))
+      .join('\n\n');
+
+    return textResponse(`Found ${attachments.length} attachment(s) for message ${messageId}:\n\n${formatted}`);
+  } catch (error) {
+    if (error.message === 'Authentication required') {
+      return textResponse("Authentication required. Please use the 'authenticate' tool first.");
+    }
+
+    return textResponse(`Error listing attachments: ${error.message}`);
+  }
+}
+
+/**
+ * Get one attachment's details and optionally save it to disk
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleGetAttachment(args = {}) {
+  const messageId = args.messageId || args.id;
+  const attachmentId = args.attachmentId;
+  const savePath = args.savePath || args.outputPath || args.out;
+  const includeContent = asBoolean(args.includeContent, false);
+  const expandItem = asBoolean(args.expandItem, false);
+  const overwrite = asBoolean(args.overwrite, false);
+
+  if (!messageId) {
+    return textResponse('Message ID is required.');
+  }
+
+  if (!attachmentId) {
+    return textResponse('Attachment ID is required.');
+  }
+
+  try {
+    const accessToken = await ensureAuthenticated();
+    const queryParams = {};
+
+    if (expandItem) {
+      queryParams.$expand = 'microsoft.graph.itemattachment/item';
+    }
+
+    const attachment = await callGraphAPI(
+      accessToken,
+      'GET',
+      `me/messages/${messageId}/attachments/${attachmentId}`,
+      null,
+      queryParams
+    );
+
+    if (!attachment || !attachment.id) {
+      return textResponse(`Attachment ${attachmentId} not found in message ${messageId}.`);
+    }
+
+    const kind = getAttachmentKind(attachment['@odata.type']);
+    const summary = [
+      `Attachment: ${attachment.name || '(unnamed attachment)'}`,
+      `ID: ${attachment.id}`,
+      `Type: ${kind}`,
+      `Content Type: ${attachment.contentType || 'unknown'}`,
+      `Size: ${attachment.size || 0} bytes`,
+      `Inline: ${attachment.isInline ? 'Yes' : 'No'}`
+    ];
+
+    if (kind === 'referenceAttachment') {
+      const sourceUrl = attachment.sourceUrl || attachment.providerType || 'Unknown';
+      summary.push(`Reference Target: ${sourceUrl}`);
+    }
+
+    if (attachment.item && typeof attachment.item === 'object') {
+      summary.push(`Attached Item Type: ${attachment.item['@odata.type'] || 'unknown'}`);
+      if (attachment.item.subject) {
+        summary.push(`Attached Item Subject: ${attachment.item.subject}`);
+      }
+    }
+
+    let downloadedBuffer = null;
+    if (savePath || includeContent) {
+      downloadedBuffer = await getAttachmentBytes(accessToken, messageId, attachment, attachmentId);
+      summary.push(`Downloaded Bytes: ${downloadedBuffer.length}`);
+    }
+
+    if (savePath) {
+      const destination = resolveOutputFilePath(
+        savePath,
+        defaultFileName(attachment, attachmentId)
+      );
+
+      ensureOutputWritable(destination, overwrite);
+      fs.writeFileSync(destination, downloadedBuffer);
+      summary.push(`Saved To: ${destination}`);
+    }
+
+    if (includeContent && downloadedBuffer) {
+      const preview = buildContentPreview(downloadedBuffer);
+      if (preview) {
+        summary.push('');
+        summary.push('Content Preview:');
+        summary.push(preview);
+      } else {
+        summary.push('');
+        summary.push('Content Preview: Binary content detected (no text preview).');
+      }
+    }
+
+    return textResponse(summary.join('\n'));
+  } catch (error) {
+    if (error.message === 'Authentication required') {
+      return textResponse("Authentication required. Please use the 'authenticate' tool first.");
+    }
+
+    return textResponse(`Error getting attachment: ${error.message}`);
+  }
+}
+
+module.exports = {
+  handleListAttachments,
+  handleGetAttachment
+};

package/email/index.js

@@ -6,6 +6,7 @@ const handleSearchEmails = require('./search');
 const handleReadEmail = require('./read');
 const handleSendEmail = require('./send');
 const handleMarkAsRead = require('./mark-as-read');
+const { handleListAttachments, handleGetAttachment } = require('./attachments');
 
 // Email tool definitions
 const emailTools = [
@@ -144,6 +145,60 @@ const emailTools = [
       required: ["id"]
     },
     handler: handleMarkAsRead
+  },
+  {
+    name: "list-attachments",
+    description: "Lists attachments for a specific email",
+    inputSchema: {
+      type: "object",
+      properties: {
+        messageId: {
+          type: "string",
+          description: "ID of the message that contains attachments"
+        },
+        count: {
+          type: "number",
+          description: "Maximum number of attachments to list (default: 25, max: 50)"
+        }
+      },
+      required: ["messageId"]
+    },
+    handler: handleListAttachments
+  },
+  {
+    name: "get-attachment",
+    description: "Gets one attachment's metadata and optionally downloads it",
+    inputSchema: {
+      type: "object",
+      properties: {
+        messageId: {
+          type: "string",
+          description: "ID of the message that contains the attachment"
+        },
+        attachmentId: {
+          type: "string",
+          description: "ID of the attachment to read or download"
+        },
+        savePath: {
+          type: "string",
+          description: "Optional output file path or output directory path"
+        },
+        includeContent: {
+          type: "boolean",
+          description: "When true, include a text preview for text-like attachments"
+        },
+        expandItem: {
+          type: "boolean",
+          description: "When true, expand item attachment metadata"
+        },
+        overwrite: {
+          type: "boolean",
+          description: "When true, overwrite an existing file at savePath"
+        }
+      },
+      required: ["messageId", "attachmentId"]
+    },
+    handler: handleGetAttachment
   }
 ];
 
@@ -153,5 +208,7 @@ module.exports = {
   handleSearchEmails,
   handleReadEmail,
   handleSendEmail,
-  handleMarkAsRead
+  handleMarkAsRead,
+  handleListAttachments,
+  handleGetAttachment
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "outlook-cli",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Production-ready Outlook CLI with optional MCP server mode powered by Microsoft Graph API",
   "keywords": [
     "outlook-cli",

package/utils/graph-api.js

@@ -11,6 +11,39 @@ function debugLog(...args) {
   }
 }
 
+function buildEncodedPath(path) {
+  return String(path || '')
+    .split('/')
+    .map((segment) => encodeURIComponent(segment))
+    .join('/');
+}
+
+function buildQueryString(queryParams = {}) {
+  if (!queryParams || Object.keys(queryParams).length === 0) {
+    return '';
+  }
+
+  const params = { ...queryParams };
+  const filter = params.$filter;
+  delete params.$filter;
+
+  let queryString = new URLSearchParams(params).toString();
+
+  if (filter) {
+    if (queryString) {
+      queryString += `&$filter=${encodeURIComponent(filter)}`;
+    } else {
+      queryString = `$filter=${encodeURIComponent(filter)}`;
+    }
+  }
+
+  if (!queryString) {
+    return '';
+  }
+
+  return `?${queryString}`;
+}
+
 /**
  * Makes a request to the Microsoft Graph API
  * @param {string} accessToken - The access token for authentication
@@ -29,45 +62,12 @@ async function callGraphAPI(accessToken, method, path, data = null, queryParams
 
   try {
     debugLog(`Making real API call: ${method} ${path}`);
-    
-    // Encode path segments properly
-    const encodedPath = path.split('/')
-      .map(segment => encodeURIComponent(segment))
-      .join('/');
-    
-    // Build query string from parameters with special handling for OData filters
-    let queryString = '';
-    if (Object.keys(queryParams).length > 0) {
-      // Handle $filter parameter specially to ensure proper URI encoding
-      const filter = queryParams.$filter;
-      if (filter) {
-        delete queryParams.$filter; // Remove from regular params
-      }
-      
-      // Build query string with proper encoding for regular params
-      const params = new URLSearchParams();
-      for (const [key, value] of Object.entries(queryParams)) {
-        params.append(key, value);
-      }
-      
-      queryString = params.toString();
-      
-      // Add filter parameter separately with proper encoding
-      if (filter) {
-        if (queryString) {
-          queryString += `&$filter=${encodeURIComponent(filter)}`;
-        } else {
-          queryString = `$filter=${encodeURIComponent(filter)}`;
-        }
-      }
-      
-      if (queryString) {
-        queryString = '?' + queryString;
-      }
-      
-      debugLog(`Query string: ${queryString}`);
-    }
-    
+
+    const encodedPath = buildEncodedPath(path);
+    const queryString = buildQueryString(queryParams);
+
+    debugLog(`Query string: ${queryString}`);
+
     const url = `${config.GRAPH_API_ENDPOINT}${encodedPath}${queryString}`;
     debugLog(`Full URL: ${url}`);
     
@@ -121,6 +121,88 @@ async function callGraphAPI(accessToken, method, path, data = null, queryParams
   }
 }
 
+/**
+ * Makes a raw request to the Microsoft Graph API and returns bytes.
+ * @param {string} accessToken - The access token for authentication
+ * @param {string} method - HTTP method (GET, POST, etc.)
+ * @param {string} path - API endpoint path
+ * @param {object} data - Data to send for POST/PUT requests
+ * @param {object} queryParams - Query parameters
+ * @returns {Promise<{statusCode:number, headers:object, body:Buffer}>}
+ */
+async function callGraphAPIRaw(accessToken, method, path, data = null, queryParams = {}) {
+  if (config.USE_TEST_MODE && accessToken.startsWith('test_access_token_')) {
+    debugLog(`TEST MODE: Simulating raw ${method} ${path} API call`);
+    return {
+      statusCode: 200,
+      headers: {
+        'content-type': 'application/octet-stream'
+      },
+      body: Buffer.from('')
+    };
+  }
+
+  try {
+    debugLog(`Making raw API call: ${method} ${path}`);
+
+    const encodedPath = buildEncodedPath(path);
+    const queryString = buildQueryString(queryParams);
+    const url = `${config.GRAPH_API_ENDPOINT}${encodedPath}${queryString}`;
+    debugLog(`Full raw URL: ${url}`);
+
+    return new Promise((resolve, reject) => {
+      const options = {
+        method,
+        headers: {
+          Authorization: `Bearer ${accessToken}`
+        }
+      };
+
+      const req = https.request(url, options, (res) => {
+        const chunks = [];
+
+        res.on('data', (chunk) => {
+          chunks.push(chunk);
+        });
+
+        res.on('end', () => {
+          const body = Buffer.concat(chunks);
+
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve({
+              statusCode: res.statusCode,
+              headers: res.headers,
+              body
+            });
+            return;
+          }
+
+          if (res.statusCode === 401) {
+            reject(new Error('UNAUTHORIZED'));
+            return;
+          }
+
+          reject(new Error(`API call failed with status ${res.statusCode}: ${body.toString('utf8')}`));
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(new Error(`Network error during API call: ${error.message}`));
+      });
+
+      if (data && (method === 'POST' || method === 'PATCH' || method === 'PUT')) {
+        req.write(JSON.stringify(data));
+      }
+
+      req.end();
+    });
+  } catch (error) {
+    debugLog('Error calling Graph API (raw):', error);
+    throw error;
+  }
+}
+
 module.exports = {
-  callGraphAPI
+  callGraphAPI,
+  callGraphAPIRaw
 };