m365-agent-cli 1.2.0

package/src/lib/markdown.ts

@@ -0,0 +1,174 @@
+function escapeHtml(value: string): string {
+  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+function sanitizeLinkUrl(url: string): string {
+  const trimmed = url.trim();
+  const withoutControlChars = Array.from(trimmed)
+    .filter((char) => {
+      const code = char.charCodeAt(0);
+      return !(
+        code <= 0x20 ||
+        (code >= 0x7f && code <= 0x9f) ||
+        code === 0x200b ||
+        code === 0x200c ||
+        code === 0x200d ||
+        code === 0xfeff
+      );
+    })
+    .join('');
+  const decoded = withoutControlChars.replace(/&(#x?[\da-f]+|[a-z]+);?/gi, (entity) => {
+    if (/^&#x/i.test(entity)) {
+      const value = Number.parseInt(entity.slice(3).replace(/;$/, ''), 16);
+      return Number.isFinite(value) ? String.fromCharCode(value) : entity;
+    }
+    if (/^&#/i.test(entity)) {
+      const value = Number.parseInt(entity.slice(2).replace(/;$/, ''), 10);
+      return Number.isFinite(value) ? String.fromCharCode(value) : entity;
+    }
+    const named: Record<string, string> = {
+      amp: '&',
+      lt: '<',
+      gt: '>',
+      quot: '"',
+      apos: "'"
+    };
+    const key = entity.slice(1).replace(/;$/, '').toLowerCase();
+    return named[key] ?? entity;
+  });
+  const lower = decoded.toLowerCase();
+
+  if (
+    lower.startsWith('javascript:') ||
+    lower.startsWith('data:') ||
+    lower.startsWith('vbscript:') ||
+    lower.startsWith('file:')
+  ) {
+    return '#';
+  }
+
+  return withoutControlChars;
+}
+
+/**
+ * Convert basic markdown to HTML for email.
+ * Supports: bold, italic, links, unordered lists, ordered lists, line breaks.
+ */
+export function markdownToHtml(text: string): string {
+  // Extract and process links first to avoid double-encoding URLs
+  const links: Array<{ placeholder: string; html: string }> = [];
+  let linkIndex = 0;
+
+  let html = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, rawUrl) => {
+    const safeUrl = sanitizeLinkUrl(rawUrl);
+    const escapedLabel = escapeHtml(label);
+    const escapedUrl = escapeHtml(safeUrl);
+    const linkHtml = `<a href="${escapedUrl}">${escapedLabel}</a>`;
+    const placeholder = `__LINK_${linkIndex}__`;
+    links.push({ placeholder, html: linkHtml });
+    linkIndex++;
+    return placeholder;
+  });
+
+  // Escape HTML in the rest of the text
+  html = escapeHtml(html);
+
+  // Restore links
+  for (const { placeholder, html: linkHtml } of links) {
+    html = html.replaceAll(placeholder, linkHtml);
+  }
+
+  // Bold: **text** or __text__
+  html = html.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+  html = html.replace(/__(.+?)__/g, '<strong>$1</strong>');
+
+  // Italic: *text* or _text_ (but not inside words)
+  html = html.replace(/(?<!\w)\*([^*]+?)\*(?!\w)/g, '<em>$1</em>');
+  html = html.replace(/(?<!\w)_([^_]+?)_(?!\w)/g, '<em>$1</em>');
+
+  // Process lists - need to handle line by line
+  const lines = html.split('\n');
+  const result: string[] = [];
+  let inUnorderedList = false;
+  let inOrderedList = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const unorderedMatch = line.match(/^[\s]*[-*]\s+(.+)$/);
+    const orderedMatch = line.match(/^[\s]*\d+\.\s+(.+)$/);
+
+    if (unorderedMatch) {
+      if (inOrderedList) {
+        result.push('</ol>');
+        inOrderedList = false;
+      }
+      if (!inUnorderedList) {
+        result.push('<ul>');
+        inUnorderedList = true;
+      }
+      result.push(`<li>${unorderedMatch[1]}</li>`);
+    } else if (orderedMatch) {
+      if (inUnorderedList) {
+        result.push('</ul>');
+        inUnorderedList = false;
+      }
+      if (!inOrderedList) {
+        result.push('<ol>');
+        inOrderedList = true;
+      }
+      result.push(`<li>${orderedMatch[1]}</li>`);
+    } else {
+      // Close any open lists
+      if (inUnorderedList) {
+        result.push('</ul>');
+        inUnorderedList = false;
+      }
+      if (inOrderedList) {
+        result.push('</ol>');
+        inOrderedList = false;
+      }
+      result.push(line);
+    }
+  }
+
+  // Close any remaining open lists
+  if (inUnorderedList) {
+    result.push('</ul>');
+  }
+  if (inOrderedList) {
+    result.push('</ol>');
+  }
+
+  html = result.join('\n');
+
+  // Convert line breaks to <br> (but not inside lists)
+  // Split by list tags, process non-list parts
+  html = html.replace(/\n(?!<\/?[uo]l>|<\/?li>)/g, '<br>\n');
+
+  // Wrap in basic HTML structure for email
+  return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<style>
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.5; }
+  a { color: #0066cc; }
+  ul, ol { margin: 10px 0; padding-left: 20px; }
+  li { margin: 5px 0; }
+</style>
+</head>
+<body>
+${html}
+</body>
+</html>`;
+}
+
+/**
+ * Check if text contains markdown formatting.
+ */
+export function hasMarkdown(text: string): boolean {
+  // Check for common markdown patterns
+  return /\*\*.+?\*\*|__.+?__|(?<!\w)\*[^*]+?\*(?!\w)|(?<!\w)_[^_]+?_(?!\w)|\[.+?\]\(.+?\)|^[\s]*[-*]\s+|^[\s]*\d+\.\s+/m.test(
+    text
+  );
+}

package/src/lib/mime-type.ts

@@ -0,0 +1,106 @@
+// Lightweight MIME type lookup using a small inline extension map.
+// This replaces the mime-types package (userland, unmaintained since 2019).
+// Only covers common file extensions used in email attachments.
+
+const MIME_TYPES: Record<string, string> = {
+  '.aac': 'audio/aac',
+  '.abw': 'application/x-abiword',
+  '.apng': 'image/apng',
+  '.arc': 'application/x-freearc',
+  '.avif': 'image/avif',
+  '.avi': 'video/x-msvideo',
+  '.azw': 'application/vnd.amazon.ebook',
+  '.bin': 'application/octet-stream',
+  '.bmp': 'image/bmp',
+  '.bz': 'application/x-bzip',
+  '.bz2': 'application/x-bzip2',
+  '.cda': 'application/x-cdf',
+  '.csh': 'application/x-csh',
+  '.class': 'application/java-vm',
+  '.css': 'text/css',
+  '.csv': 'text/csv',
+  '.doc': 'application/msword',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.epub': 'application/epub+zip',
+  '.gz': 'application/gzip',
+  '.gif': 'image/gif',
+  '.gpx': 'application/gpx+xml',
+  '.htm': 'text/html',
+  '.html': 'text/html',
+  '.ico': 'image/x-icon',
+  '.ics': 'text/calendar',
+  '.jar': 'application/java-archive',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.js': 'text/javascript',
+  '.json': 'application/json',
+  '.jsonld': 'application/ld+json',
+  '.kml': 'application/vnd.google-earth.kml+xml',
+  '.kmz': 'application/vnd.google-earth.kmz',
+  '.log': 'text/plain',
+  '.m3u8': 'application/vnd.apple.mpegurl',
+  '.m4a': 'audio/mp4',
+  '.md': 'text/markdown',
+  '.mid': 'audio/midi',
+  '.midi': 'audio/midi',
+  '.mjs': 'text/javascript',
+  '.mov': 'video/quicktime',
+  '.mp3': 'audio/mpeg',
+  '.mp4': 'video/mp4',
+  '.mpeg': 'video/mpeg',
+  '.mpg': 'video/mpeg',
+  '.odp': 'application/vnd.oasis.opendocument.presentation',
+  '.ods': 'application/vnd.oasis.opendocument.spreadsheet',
+  '.odt': 'application/vnd.oasis.opendocument.text',
+  '.oga': 'audio/ogg',
+  '.ogv': 'video/ogg',
+  '.ogx': 'application/ogg',
+  '.opus': 'audio/opus',
+  '.otf': 'font/otf',
+  '.pdf': 'application/pdf',
+  '.php': 'application/x-httpd-php',
+  '.png': 'image/png',
+  '.ppt': 'application/vnd.ms-powerpoint',
+  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  '.psd': 'image/vnd.adobe.photoshop',
+  '.py': 'text/x-python',
+  '.rar': 'application/vnd.rar',
+  '.rtf': 'application/rtf',
+  '.sh': 'application/x-sh',
+  '.svg': 'image/svg+xml',
+  '.tar': 'application/x-tar',
+  '.tbz': 'application/x-bzip-compressed-tar',
+  '.tbz2': 'application/x-bzip-compressed-tar',
+  '.tgz': 'application/x-tar-gz',
+  '.tif': 'image/tiff',
+  '.tiff': 'image/tiff',
+  '.ts': 'video/mp2t',
+  '.ttf': 'font/ttf',
+  '.txt': 'text/plain',
+  '.vsd': 'application/vnd.visio',
+  '.wav': 'audio/wav',
+  '.weba': 'audio/webm',
+  '.webm': 'video/webm',
+  '.webp': 'image/webp',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.xhtml': 'application/xhtml+xml',
+  '.xls': 'application/vnd.ms-excel',
+  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  '.xml': 'application/xml',
+  '.xul': 'application/vnd.mozilla.xul+xml',
+  '.zip': 'application/zip',
+  '.3gp': 'video/3gpp',
+  '.3g2': 'video/3gpp2',
+  '.7z': 'application/x-7z-compressed'
+};
+
+/**
+ * Look up MIME type by file extension.
+ * Returns 'application/octet-stream' for unknown extensions.
+ */
+export function lookupMimeType(filename: string): string {
+  const ext = filename.toLowerCase().match(/\.[^.]+$/)?.[0];
+  return ext ? MIME_TYPES[ext] || 'application/octet-stream' : 'application/octet-stream';
+}

package/src/lib/oof-client.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'bun:test';
+import { getMailboxSettings, setMailboxSettings } from './oof-client.js';
+
+describe('oof-client', () => {
+  const token = 'test-token';
+
+  it('getMailboxSettings handles GET', async () => {
+    const fetchCalls: any[] = [];
+    const originalFetch = globalThis.fetch;
+    try {
+      globalThis.fetch = (async (input, init) => {
+        fetchCalls.push({ input, init });
+        return new Response(JSON.stringify({ automaticRepliesSetting: { status: 'disabled' } }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' }
+        });
+      }) as typeof fetch;
+
+      const res = await getMailboxSettings(token);
+      expect(res.ok).toBe(true);
+      expect(res.data?.automaticRepliesSetting?.status).toBe('disabled');
+      expect(fetchCalls).toHaveLength(1);
+      expect(fetchCalls[0].input.toString()).toContain('/me/mailboxSettings');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('setMailboxSettings handles PATCH with scheduled time', async () => {
+    const fetchCalls: any[] = [];
+    const originalFetch = globalThis.fetch;
+    try {
+      globalThis.fetch = (async (input, init) => {
+        fetchCalls.push({ input, init });
+        return new Response('', { status: 204 });
+      }) as typeof fetch;
+
+      const res = await setMailboxSettings(token, {
+        status: 'scheduled',
+        internalReplyMessage: 'Away',
+        scheduledStartDateTime: '2025-01-01T00:00:00.000Z'
+      });
+
+      expect(res.ok).toBe(true);
+      expect(fetchCalls).toHaveLength(1);
+      expect(fetchCalls[0].init.method).toBe('PATCH');
+
+      const body = JSON.parse(fetchCalls[0].init.body);
+      expect(body.automaticRepliesSetting.status).toBe('scheduled');
+      expect(body.automaticRepliesSetting.internalReplyMessage).toBe('Away');
+      expect(body.automaticRepliesSetting.scheduledStartDateTime).toEqual({
+        dateTime: '2025-01-01T00:00:00.000Z',
+        timeZone: 'UTC'
+      });
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});

package/src/lib/oof-client.ts

@@ -0,0 +1,122 @@
+import { callGraph, GraphApiError, graphError } from './graph-client.js';
+import { graphUserPath } from './graph-user-path.js';
+
+export type OofStatus = 'alwaysEnabled' | 'scheduled' | 'disabled';
+
+export interface DateTimeTimeZone {
+  dateTime: string;
+  timeZone: string;
+}
+
+export interface AutomaticRepliesSetting {
+  status: OofStatus;
+  internalReplyMessage?: string;
+  externalReplyMessage?: string;
+  scheduledStartDateTime?: DateTimeTimeZone;
+  scheduledEndDateTime?: DateTimeTimeZone;
+}
+
+export interface MailboxSettings {
+  automaticRepliesSetting?: AutomaticRepliesSetting;
+  timeZone?: string;
+}
+
+export interface GetMailboxSettingsResponse {
+  automaticRepliesSetting?: AutomaticRepliesSetting;
+  timeZone?: string;
+}
+
+export async function getMailboxSettings(
+  token: string,
+  user?: string
+): Promise<{
+  ok: boolean;
+  data?: GetMailboxSettingsResponse;
+  error?: { message: string; code?: string; status?: number };
+}> {
+  try {
+    return await callGraph<GetMailboxSettingsResponse>(token, graphUserPath(user, 'mailboxSettings'));
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status) as {
+        ok: boolean;
+        data?: GetMailboxSettingsResponse;
+        error?: { message: string; code?: string; status?: number };
+      };
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to get mailbox settings') as {
+      ok: boolean;
+      data?: GetMailboxSettingsResponse;
+      error?: { message: string; code?: string; status?: number };
+    };
+  }
+}
+
+export async function setMailboxSettings(
+  token: string,
+  settings: Omit<Partial<AutomaticRepliesSetting>, 'scheduledStartDateTime' | 'scheduledEndDateTime'> & {
+    scheduledStartDateTime?: string | DateTimeTimeZone;
+    scheduledEndDateTime?: string | DateTimeTimeZone;
+  },
+  user?: string
+): Promise<{
+  ok: boolean;
+  error?: { message: string; code?: string; status?: number };
+}> {
+  const payload = {
+    automaticRepliesSetting: {
+      ...(settings.status !== undefined ? { status: settings.status } : {}),
+      ...(settings.internalReplyMessage !== undefined ? { internalReplyMessage: settings.internalReplyMessage } : {}),
+      ...(settings.externalReplyMessage !== undefined ? { externalReplyMessage: settings.externalReplyMessage } : {}),
+      ...(settings.scheduledStartDateTime !== undefined
+        ? {
+            scheduledStartDateTime:
+              typeof settings.scheduledStartDateTime === 'string'
+                ? { dateTime: settings.scheduledStartDateTime, timeZone: 'UTC' }
+                : settings.scheduledStartDateTime
+          }
+        : {}),
+      ...(settings.scheduledEndDateTime !== undefined
+        ? {
+            scheduledEndDateTime:
+              typeof settings.scheduledEndDateTime === 'string'
+                ? { dateTime: settings.scheduledEndDateTime, timeZone: 'UTC' }
+                : settings.scheduledEndDateTime
+          }
+        : {})
+    }
+  };
+
+  let result: any;
+  try {
+    result = await callGraph<Record<string, never>>(
+      token,
+      graphUserPath(user, 'mailboxSettings'),
+      {
+        method: 'PATCH',
+        body: JSON.stringify(payload)
+      },
+      false // don't expect JSON on 204
+    );
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return {
+        ok: false,
+        error: { message: err.message, code: err.code, status: err.status }
+      };
+    }
+    return {
+      ok: false,
+      error: { message: err instanceof Error ? err.message : 'Failed to update mailbox settings' }
+    };
+  }
+
+  if (!result.ok) {
+    return {
+      ok: false,
+      error: result.error || { message: 'Failed to update mailbox settings' }
+    };
+  }
+
+  return { ok: true };
+}

package/src/lib/outlook-graph-client.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, it } from 'bun:test';
+
+const token = 'test-token';
+const baseUrl = 'https://graph.microsoft.com/v1.0';
+
+describe('listMailFolders', () => {
+  it('GETs /mailFolders collection', async () => {
+    process.env.GRAPH_BASE_URL = baseUrl;
+    const urls: string[] = [];
+    const originalFetch = globalThis.fetch;
+
+    try {
+      globalThis.fetch = (async (input: string | URL | Request) => {
+        urls.push(typeof input === 'string' ? input : input.toString());
+        return new Response(
+          JSON.stringify({
+            value: [{ id: 'inbox-id', displayName: 'Inbox' }]
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } }
+        );
+      }) as typeof fetch;
+
+      const { listMailFolders } = await import('./outlook-graph-client.js');
+      const r = await listMailFolders(token);
+
+      expect(r.ok).toBe(true);
+      expect(r.data?.[0]?.displayName).toBe('Inbox');
+      expect(urls[0]).toContain('/me/mailFolders');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe('getMessage', () => {
+  it('GETs /messages/{id}', async () => {
+    process.env.GRAPH_BASE_URL = baseUrl;
+    const urls: string[] = [];
+    const originalFetch = globalThis.fetch;
+
+    try {
+      globalThis.fetch = (async (input: string | URL | Request) => {
+        urls.push(typeof input === 'string' ? input : input.toString());
+        return new Response(JSON.stringify({ id: 'msg-1', subject: 'Hi', isRead: false }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' }
+        });
+      }) as typeof fetch;
+
+      const { getMessage } = await import('./outlook-graph-client.js');
+      const r = await getMessage(token, 'msg-1', undefined, 'subject,isRead');
+
+      expect(r.ok).toBe(true);
+      expect(r.data?.subject).toBe('Hi');
+      expect(urls[0]).toContain('/me/messages/msg-1');
+      expect(urls[0]).toContain('$select=');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe('listMailboxMessages', () => {
+  it('GETs /me/messages', async () => {
+    process.env.GRAPH_BASE_URL = baseUrl;
+    const urls: string[] = [];
+    const originalFetch = globalThis.fetch;
+
+    try {
+      globalThis.fetch = (async (input: string | URL | Request) => {
+        urls.push(typeof input === 'string' ? input : input.toString());
+        return new Response(JSON.stringify({ value: [{ id: 'm1', subject: 'A' }] }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' }
+        });
+      }) as typeof fetch;
+
+      const { listMailboxMessages } = await import('./outlook-graph-client.js');
+      const r = await listMailboxMessages(token, undefined, { top: 10 });
+
+      expect(r.ok).toBe(true);
+      expect(urls[0]).toContain('/me/messages');
+      expect(decodeURIComponent(urls[0])).toContain('$top=10');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('adds ConsistencyLevel when using search', async () => {
+    process.env.GRAPH_BASE_URL = baseUrl;
+    let consistency: string | undefined;
+    const originalFetch = globalThis.fetch;
+
+    try {
+      globalThis.fetch = (async (_input: string | URL | Request, init?: RequestInit) => {
+        const h = init?.headers;
+        if (h instanceof Headers) {
+          consistency = h.get('ConsistencyLevel') ?? undefined;
+        } else if (h && typeof h === 'object') {
+          consistency = (h as Record<string, string>).ConsistencyLevel;
+        }
+        return new Response(JSON.stringify({ value: [] }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' }
+        });
+      }) as typeof fetch;
+
+      const { listMailboxMessages } = await import('./outlook-graph-client.js');
+      const r = await listMailboxMessages(token, undefined, { top: 5, search: 'budget' });
+
+      expect(r.ok).toBe(true);
+      expect(consistency).toBe('eventual');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe('sendMail', () => {
+  it('POSTs /sendMail', async () => {
+    process.env.GRAPH_BASE_URL = baseUrl;
+    const urls: string[] = [];
+    const bodies: string[] = [];
+    const originalFetch = globalThis.fetch;
+
+    try {
+      globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+        urls.push(typeof input === 'string' ? input : input.toString());
+        if (init?.body && typeof init.body === 'string') bodies.push(init.body);
+        return new Response(null, { status: 202 });
+      }) as typeof fetch;
+
+      const { sendMail } = await import('./outlook-graph-client.js');
+      const r = await sendMail(token, {
+        message: { subject: 'Hi', body: { contentType: 'Text', content: 'x' } },
+        saveToSentItems: true
+      });
+
+      expect(r.ok).toBe(true);
+      expect(urls[0]).toContain('/me/sendMail');
+      expect(bodies[0]).toContain('saveToSentItems');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});