m365-agent-cli 1.2.0

package/src/lib/rules-client.ts

@@ -0,0 +1,178 @@
+import type { GraphResponse } from './graph-client.js';
+import { callGraph, GraphApiError, graphError, graphResult } from './graph-client.js';
+import { graphUserPath } from './graph-user-path.js';
+
+function inboxRulesBase(user?: string): string {
+  return `${graphUserPath(user, 'mailFolders/inbox/messageRules')}`;
+}
+
+export interface MessageRuleCondition {
+  /** Strings the message body contains (case-insensitive) */
+  bodyContains?: string[];
+  /** Strings the message subject contains (case-insensitive) */
+  subjectContains?: string[];
+  /** Strings the message sender contains (case-insensitive) */
+  senderContains?: string[];
+  /** Strings any recipient contains (case-insensitive) */
+  recipientContains?: string[];
+  /** Senders to match */
+  fromAddresses?: { emailAddress: { name?: string; address: string } }[];
+  /** Recipients to match */
+  sentToAddresses?: { emailAddress: { name?: string; address: string } }[];
+  /** Message has attachments */
+  hasAttachments?: boolean;
+  /** Importance: low | normal | high */
+  importance?: 'Low' | 'Normal' | 'High';
+  /** Message is an automatic forward */
+  isAutomaticForward?: boolean;
+}
+
+export interface MessageRuleAction {
+  /** Move message to this folder (name or well-known name) */
+  moveToFolder?: string;
+  /** Copy message to this folder */
+  copyToFolder?: string;
+  /** Soft-delete the message */
+  delete?: boolean;
+  /** Permanently delete the message */
+  permanentDelete?: boolean;
+  /** Mark as read */
+  markAsRead?: boolean;
+  /** Set importance: low | normal | high */
+  markImportance?: 'Low' | 'Normal' | 'High';
+  /** Forward to these recipients */
+  forwardToRecipients?: { emailAddress: { name?: string; address: string } }[];
+  /** Forward as attachment to these recipients */
+  forwardAsAttachmentToRecipients?: { emailAddress: { name?: string; address: string } }[];
+  /** Assign categories */
+  assignCategories?: string[];
+  /** Stop processing more rules */
+  stopProcessingRules?: boolean;
+}
+
+export interface MessageRule {
+  id: string;
+  displayName: string;
+  priority: number;
+  isEnabled: boolean;
+  conditions?: MessageRuleCondition;
+  actions?: MessageRuleAction;
+  exceptionConditions?: MessageRuleCondition;
+  /** Human-readable description auto-generated by Exchange */
+  ruleDescription?: string;
+}
+
+interface MessageRuleListResponse {
+  value: MessageRule[];
+}
+
+export interface CreateMessageRulePayload {
+  displayName: string;
+  priority?: number;
+  isEnabled?: boolean;
+  conditions?: MessageRuleCondition;
+  actions: MessageRuleAction;
+  exceptionConditions?: MessageRuleCondition;
+}
+
+export interface UpdateMessageRulePayload {
+  displayName?: string;
+  priority?: number;
+  isEnabled?: boolean;
+  conditions?: MessageRuleCondition;
+  actions?: MessageRuleAction;
+  exceptionConditions?: MessageRuleCondition;
+}
+
+/** List all inbox message rules */
+export async function listMessageRules(token: string, user?: string): Promise<GraphResponse<MessageRule[]>> {
+  let result: GraphResponse<MessageRuleListResponse>;
+  try {
+    result = await callGraph<MessageRuleListResponse>(token, inboxRulesBase(user));
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to list message rules');
+  }
+  if (!result.ok || !result.data) {
+    return graphError(
+      result.error?.message || 'Failed to list message rules',
+      result.error?.code,
+      result.error?.status
+    );
+  }
+  return graphResult(result.data.value || []);
+}
+
+/** Get a single message rule by ID */
+export async function getMessageRule(
+  token: string,
+  ruleId: string,
+  user?: string
+): Promise<GraphResponse<MessageRule>> {
+  try {
+    return await callGraph<MessageRule>(token, `${inboxRulesBase(user)}/${encodeURIComponent(ruleId)}`);
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to get message rule');
+  }
+}
+
+/** Create a new inbox message rule */
+export async function createMessageRule(
+  token: string,
+  payload: CreateMessageRulePayload,
+  user?: string
+): Promise<GraphResponse<MessageRule>> {
+  try {
+    return await callGraph<MessageRule>(token, inboxRulesBase(user), {
+      method: 'POST',
+      body: JSON.stringify(payload)
+    });
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to create message rule');
+  }
+}
+
+/** Update an existing inbox message rule */
+export async function updateMessageRule(
+  token: string,
+  ruleId: string,
+  payload: UpdateMessageRulePayload,
+  user?: string
+): Promise<GraphResponse<MessageRule>> {
+  try {
+    return await callGraph<MessageRule>(token, `${inboxRulesBase(user)}/${encodeURIComponent(ruleId)}`, {
+      method: 'PATCH',
+      body: JSON.stringify(payload)
+    });
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to update message rule');
+  }
+}
+
+/** Delete an inbox message rule */
+export async function deleteMessageRule(token: string, ruleId: string, user?: string): Promise<GraphResponse<void>> {
+  try {
+    return await callGraph<void>(
+      token,
+      `${inboxRulesBase(user)}/${encodeURIComponent(ruleId)}`,
+      { method: 'DELETE' },
+      false
+    );
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to delete message rule');
+  }
+}

package/src/lib/sharepoint-client.ts

@@ -0,0 +1,101 @@
+import {
+  callGraph,
+  fetchAllPages,
+  GraphApiError,
+  type GraphResponse,
+  graphError,
+  graphResult
+} from './graph-client.js';
+
+export interface SharePointList {
+  id: string;
+  name: string;
+  displayName: string;
+  description?: string;
+  createdDateTime: string;
+  lastModifiedDateTime: string;
+  webUrl: string;
+}
+
+export interface SharePointListItem {
+  id: string;
+  createdDateTime: string;
+  lastModifiedDateTime: string;
+  webUrl: string;
+  fields: Record<string, any>;
+}
+
+export async function getLists(token: string, siteId: string): Promise<GraphResponse<SharePointList[]>> {
+  let res: GraphResponse<{ value: SharePointList[] }>;
+  try {
+    res = await callGraph<{ value: SharePointList[] }>(token, `/sites/${siteId}/lists`);
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to get lists');
+  }
+  if (!res.ok || !res.data?.value) return graphError('Failed to get lists: missing data');
+  return graphResult(res.data.value);
+}
+
+export async function getListItems(
+  token: string,
+  siteId: string,
+  listId: string
+): Promise<GraphResponse<SharePointListItem[]>> {
+  return fetchAllPages<SharePointListItem>(
+    token,
+    `/sites/${siteId}/lists/${encodeURIComponent(listId)}/items?$expand=fields`,
+    'Failed to get list items'
+  );
+}
+
+export async function createListItem(
+  token: string,
+  siteId: string,
+  listId: string,
+  fields: Record<string, any>
+): Promise<GraphResponse<SharePointListItem>> {
+  try {
+    return await callGraph<SharePointListItem>(token, `/sites/${siteId}/lists/${encodeURIComponent(listId)}/items`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({ fields })
+    });
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to create list item');
+  }
+}
+
+export async function updateListItem(
+  token: string,
+  siteId: string,
+  listId: string,
+  itemId: string,
+  fields: Record<string, any>
+): Promise<GraphResponse<Record<string, any>>> {
+  try {
+    return await callGraph<Record<string, any>>(
+      token,
+      `/sites/${siteId}/lists/${encodeURIComponent(listId)}/items/${encodeURIComponent(itemId)}/fields`,
+      {
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(fields)
+      }
+    );
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to update list item');
+  }
+}

package/src/lib/site-pages-client.ts

@@ -0,0 +1,73 @@
+import { callGraph, fetchAllPages, GraphApiError, type GraphResponse, graphError } from './graph-client.js';
+
+export interface SitePage {
+  id: string;
+  name?: string;
+  title?: string;
+  pageLayout?: string;
+  publishingState?: {
+    level: string;
+    versionId: string;
+  };
+  webUrl?: string;
+  [key: string]: any;
+}
+
+export async function listSitePages(token: string, siteId: string): Promise<GraphResponse<SitePage[]>> {
+  return fetchAllPages<SitePage>(token, `/sites/${siteId}/pages/microsoft.graph.sitePage`, 'Failed to list site pages');
+}
+
+export async function getSitePage(token: string, siteId: string, pageId: string): Promise<GraphResponse<SitePage>> {
+  try {
+    return await callGraph<SitePage>(
+      token,
+      `/sites/${siteId}/pages/${encodeURIComponent(pageId)}/microsoft.graph.sitePage`
+    );
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to get site page');
+  }
+}
+
+export async function updateSitePage(
+  token: string,
+  siteId: string,
+  pageId: string,
+  pageData: Partial<SitePage>
+): Promise<GraphResponse<SitePage>> {
+  try {
+    return await callGraph<SitePage>(
+      token,
+      `/sites/${siteId}/pages/${encodeURIComponent(pageId)}/microsoft.graph.sitePage`,
+      {
+        method: 'PATCH',
+        body: JSON.stringify({ '@odata.type': '#microsoft.graph.sitePage', ...pageData })
+      }
+    );
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to update site page');
+  }
+}
+
+export async function publishSitePage(token: string, siteId: string, pageId: string): Promise<GraphResponse<void>> {
+  try {
+    return await callGraph<void>(
+      token,
+      `/sites/${siteId}/pages/${encodeURIComponent(pageId)}/microsoft.graph.sitePage/publish`,
+      {
+        method: 'POST'
+      },
+      false // might not return JSON, just 204 No Content
+    );
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to publish site page');
+  }
+}

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

@@ -0,0 +1,298 @@
+import { describe, expect, it } from 'bun:test';
+
+const token = 'test-token';
+const baseUrl = 'https://graph.microsoft.com/v1.0';
+
+describe('linkedResourceToGraphPayload', () => {
+  it('prefers displayName over description', async () => {
+    const { linkedResourceToGraphPayload } = await import('./todo-client.js');
+    expect(linkedResourceToGraphPayload({ displayName: 'A', description: 'B', webUrl: 'https://example.com' })).toEqual(
+      {
+        displayName: 'A',
+        webUrl: 'https://example.com'
+      }
+    );
+  });
+
+  it('uses description when displayName absent', async () => {
+    const { linkedResourceToGraphPayload } = await import('./todo-client.js');
+    expect(linkedResourceToGraphPayload({ description: 'Only', webUrl: 'https://x' })).toEqual({
+      displayName: 'Only',
+      webUrl: 'https://x'
+    });
+  });
+
+  it('includes optional applicationName, externalId, id', async () => {
+    const { linkedResourceToGraphPayload } = await import('./todo-client.js');
+    expect(
+      linkedResourceToGraphPayload({
+        displayName: 'T',
+        applicationName: 'App',
+        externalId: 'ext-1',
+        id: 'lr-id'
+      })
+    ).toEqual({
+      displayName: 'T',
+      applicationName: 'App',
+      externalId: 'ext-1',
+      id: 'lr-id'
+    });
+  });
+
+  it('omits empty displayName string', async () => {
+    const { linkedResourceToGraphPayload } = await import('./todo-client.js');
+    expect(linkedResourceToGraphPayload({ description: '', webUrl: 'https://u' })).toEqual({
+      webUrl: 'https://u'
+    });
+  });
+});
+
+describe('getTasks query options', () => {
+  it('requests single page with $top, $skip, $expand, $count', 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: [] }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' }
+        });
+      }) as typeof fetch;
+
+      const { getTasks } = await import('./todo-client.js');
+      const r = await getTasks(token, 'list-1', {
+        filter: "status eq 'notStarted'",
+        top: 10,
+        skip: 5,
+        expand: 'attachments',
+        count: true
+      });
+
+      expect(r.ok).toBe(true);
+      expect(r.data).toEqual([]);
+      const u = decodeURIComponent(urls[0]);
+      expect(u).toContain('$top=10');
+      expect(u).toContain('$skip=5');
+      expect(u).toContain('$expand=attachments');
+      expect(u).toContain('$count=true');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe('getTask $select', () => {
+  it('appends $select when provided', 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: 't1', title: 'x' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' }
+        });
+      }) as typeof fetch;
+
+      const { getTask } = await import('./todo-client.js');
+      const r = await getTask(token, 'list-1', 'task-1', undefined, { select: 'id,title' });
+
+      expect(r.ok).toBe(true);
+      expect(urls[0]).toContain('$select=');
+      expect(decodeURIComponent(urls[0])).toContain('id,title');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe('getTodoLists / getTodoList', () => {
+  it('getTodoLists returns lists from value', 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: 'l1', displayName: 'Work', wellknownListName: 'none' }]
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } }
+        );
+      }) as typeof fetch;
+
+      const { getTodoLists } = await import('./todo-client.js');
+      const r = await getTodoLists(token);
+
+      expect(r.ok).toBe(true);
+      expect(r.data?.[0]?.id).toBe('l1');
+      expect(urls[0]).toContain('/me/todo/lists');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('getTodoList returns one list', async () => {
+    process.env.GRAPH_BASE_URL = baseUrl;
+    const originalFetch = globalThis.fetch;
+
+    try {
+      globalThis.fetch = (async (_input: string | URL | Request) => {
+        return new Response(JSON.stringify({ id: 'l2', displayName: 'Home', wellknownListName: 'none' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' }
+        });
+      }) as typeof fetch;
+
+      const { getTodoList } = await import('./todo-client.js');
+      const r = await getTodoList(token, 'l2');
+
+      expect(r.ok).toBe(true);
+      expect(r.data?.displayName).toBe('Home');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe('getTasks string filter (paging)', () => {
+  it('uses fetchAllPages for string $filter only', 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: 't1', title: 'a', status: 'completed' }] }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' }
+        });
+      }) as typeof fetch;
+
+      const { getTasks } = await import('./todo-client.js');
+      const r = await getTasks(token, 'list-1', "status eq 'completed'");
+
+      expect(r.ok).toBe(true);
+      expect(r.data).toHaveLength(1);
+      const q = decodeURIComponent(urls[0].replace(/\+/g, ' '));
+      expect(q).toContain("$filter=status eq 'completed'");
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe('createTask', () => {
+  it('POSTs payload with optional fields', async () => {
+    process.env.GRAPH_BASE_URL = baseUrl;
+    const posts: { url: string; body: string }[] = [];
+    const originalFetch = globalThis.fetch;
+
+    try {
+      globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+        const url = typeof input === 'string' ? input : input.toString();
+        if (init?.method === 'POST' && init.body) {
+          posts.push({ url, body: String(init.body) });
+        }
+        return new Response(JSON.stringify({ id: 'new-id', title: 'Created', status: 'notStarted' }), {
+          status: 201,
+          headers: { 'content-type': 'application/json' }
+        });
+      }) as typeof fetch;
+
+      const { createTask } = await import('./todo-client.js');
+      const r = await createTask(token, 'list-x', {
+        title: 'Created',
+        body: '<p>x</p>',
+        bodyContentType: 'html',
+        dueDateTime: '2026-06-01T12:00:00',
+        startDateTime: '2026-06-01T09:00:00',
+        timeZone: 'Europe/Stockholm',
+        importance: 'high',
+        status: 'notStarted',
+        isReminderOn: true,
+        reminderDateTime: '2026-06-01T08:00:00',
+        linkedResources: [{ displayName: 'Link', webUrl: 'https://example.com' }],
+        categories: ['Cat1'],
+        recurrence: { pattern: { type: 'daily', interval: 1 } }
+      });
+
+      expect(r.ok).toBe(true);
+      expect(r.data?.id).toBe('new-id');
+      expect(posts).toHaveLength(1);
+      expect(posts[0].url).toContain('/lists/list-x/tasks');
+      const payload = JSON.parse(posts[0].body) as Record<string, unknown>;
+      expect(payload.title).toBe('Created');
+      expect(payload.body).toEqual({ content: '<p>x</p>', contentType: 'html' });
+      expect(payload.importance).toBe('high');
+      expect(payload.categories).toEqual(['Cat1']);
+      expect(Array.isArray(payload.linkedResources)).toBe(true);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe('getChecklistItem', () => {
+  it('GETs one checklist item by 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: 'ck1',
+            displayName: 'Buy milk',
+            isChecked: false,
+            createdDateTime: '2026-01-01T12:00:00.000Z'
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } }
+        );
+      }) as typeof fetch;
+
+      const { getChecklistItem } = await import('./todo-client.js');
+      const r = await getChecklistItem(token, 'list-1', 'task-1', 'ck1');
+
+      expect(r.ok).toBe(true);
+      expect(r.data?.displayName).toBe('Buy milk');
+      expect(urls[0]).toContain('/checklistItems/ck1');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe('getTaskAttachmentContent', () => {
+  it('GETs raw bytes from attachments/$value', async () => {
+    process.env.GRAPH_BASE_URL = baseUrl;
+    const originalFetch = globalThis.fetch;
+
+    try {
+      globalThis.fetch = (async (input: string | URL | Request) => {
+        const u = typeof input === 'string' ? input : input.toString();
+        expect(u).toContain('$value');
+        return new Response(new Uint8Array([7, 8, 9]), { status: 200 });
+      }) as typeof fetch;
+
+      const { getTaskAttachmentContent } = await import('./todo-client.js');
+      const r = await getTaskAttachmentContent(token, 'list-1', 'task-1', 'att-1');
+
+      expect(r.ok).toBe(true);
+      expect(r.data?.length).toBe(3);
+      expect(r.data?.[0]).toBe(7);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});