m365-agent-cli 1.2.0

package/src/commands/respond.ts

@@ -0,0 +1,291 @@
+import { Command } from 'commander';
+import { resolveAuth } from '../lib/auth.js';
+import {
+  getCalendarEvent,
+  getCalendarEvents,
+  getOwaUserInfo,
+  type ResponseType,
+  respondToEvent
+} from '../lib/ews-client.js';
+import { checkReadOnly } from '../lib/utils.js';
+
+function formatTime(dateStr: string): string {
+  const date = new Date(dateStr);
+  return date.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: false });
+}
+
+function formatDate(dateStr: string): string {
+  const date = new Date(dateStr);
+  return date.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' });
+}
+
+function getResponseIcon(response: string): string {
+  switch (response) {
+    case 'Accepted':
+      return '\u2713';
+    case 'Declined':
+      return '\u2717';
+    case 'TentativelyAccepted':
+      return '?';
+    case 'None':
+    case 'NotResponded':
+      return '\u2022';
+    default:
+      return ' ';
+  }
+}
+
+export const respondCommand = new Command('respond')
+  .description('Respond to calendar invitations (accept/decline/tentative)')
+  .argument('[action]', 'Action: list, accept, decline, tentative')
+  .argument('[eventIndex]', 'Event index from the list (deprecated; use --id)')
+  .option('--id <eventId>', 'Respond to a specific event by stable ID')
+  .option('--comment <text>', 'Add a comment to your response')
+  .option('--no-notify', "Don't send response to organizer")
+  .option('--include-optional', 'Include optional invitations (default)', true)
+  .option('--only-required', 'Only show required invitations')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific token')
+  .option('--identity <name>', 'Use a specific authentication identity (default: default)')
+  .option('--mailbox <email>', 'Respond to event in shared mailbox calendar')
+  .action(
+    async (
+      action: string | undefined,
+      _eventIndex: string | undefined,
+      options: {
+        id?: string;
+        comment?: string;
+        notify: boolean;
+        includeOptional?: boolean;
+        onlyRequired?: boolean;
+        json?: boolean;
+        token?: string;
+        identity?: string;
+        mailbox?: string;
+      },
+      cmd: any
+    ) => {
+      const authResult = await resolveAuth({
+        token: options.token,
+        identity: options.identity
+      });
+
+      if (!authResult.success) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: authResult.error }, null, 2));
+        } else {
+          console.error(`Error: ${authResult.error}`);
+          console.error('\nCheck your .env file for EWS_CLIENT_ID and EWS_REFRESH_TOKEN.');
+        }
+        process.exit(1);
+      }
+
+      // Get user's email to identify their response status
+      const userInfo = await getOwaUserInfo(authResult.token!);
+      const userEmail = userInfo.ok ? userInfo.data?.email?.toLowerCase() : undefined;
+
+      // When using a shared mailbox, the attendee email is the mailbox, not the authenticated user
+      const attendeeEmail = options.mailbox?.toLowerCase() || userEmail;
+
+      if (!attendeeEmail) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: 'Failed to determine user email' }, null, 2));
+        } else {
+          console.error('Error: Failed to determine user email');
+        }
+        process.exit(1);
+      }
+
+      // Fetch upcoming events
+      const now = new Date();
+      const futureDate = new Date(now);
+      futureDate.setDate(futureDate.getDate() + 31); // Look 31 days ahead to avoid boundary misses
+
+      const result = await getCalendarEvents(
+        authResult.token!,
+        now.toISOString(),
+        futureDate.toISOString(),
+        options.mailbox
+      );
+
+      if (!result.ok || !result.data) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: result.error?.message || 'Failed to fetch events' }, null, 2));
+        } else {
+          console.error(`Error: ${result.error?.message || 'Failed to fetch events'}`);
+        }
+        process.exit(1);
+      }
+
+      // Filter to events where user is an attendee (and not organizer)
+      const pendingEvents = result.data.filter((event) => {
+        if (event.IsCancelled) return false;
+        if (event.IsOrganizer) return false;
+
+        // Find user's attendance record
+        const myAttendance = event.Attendees?.find((a) => a.EmailAddress?.Address?.toLowerCase() === attendeeEmail);
+
+        // Some events don't include attendee records; fall back to event-level ResponseStatus if present
+        const eventResponse = (event as any).ResponseStatus?.Response as string | undefined;
+        const response = myAttendance?.Status?.Response || eventResponse || 'None';
+
+        // Include events where response is None or NotResponded
+        const isPending = response === 'None' || response === 'NotResponded';
+        if (!isPending) return false;
+
+        // Optional attendance handling (only if we can detect it)
+        const isOptional = myAttendance?.Type === 'Optional';
+        if (options.onlyRequired && isOptional) return false;
+
+        return true;
+      });
+
+      // Default action is 'list'
+      const actionLower = (action || 'list').toLowerCase();
+
+      if (actionLower === 'list') {
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                pendingEvents: pendingEvents.map((e, i) => ({
+                  index: i + 1,
+                  id: e.Id,
+                  subject: e.Subject,
+                  start: e.Start.DateTime,
+                  end: e.End.DateTime,
+                  organizer: e.Organizer?.EmailAddress?.Name || e.Organizer?.EmailAddress?.Address,
+                  location: e.Location?.DisplayName
+                }))
+              },
+              null,
+              2
+            )
+          );
+          return;
+        }
+
+        console.log('\nCalendar invitations awaiting your response:\n');
+        console.log('\u2500'.repeat(60));
+
+        if (pendingEvents.length === 0) {
+          console.log('\n  No pending invitations found.\n');
+          return;
+        }
+
+        for (let i = 0; i < pendingEvents.length; i++) {
+          const event = pendingEvents[i];
+          const dateStr = formatDate(event.Start.DateTime);
+          const startTime = formatTime(event.Start.DateTime);
+          const endTime = formatTime(event.End.DateTime);
+
+          const myAttendance = event.Attendees?.find((a) => a.EmailAddress?.Address?.toLowerCase() === attendeeEmail);
+          const eventResponse = (event as any).ResponseStatus?.Response as string | undefined;
+          const response = myAttendance?.Status?.Response || eventResponse || 'None';
+          const icon = getResponseIcon(response);
+
+          console.log(`\n  [${i + 1}] ${icon} ${event.Subject}`);
+          console.log(`      ${dateStr} ${startTime} - ${endTime}`);
+          console.log(`      ID: ${event.Id}`);
+          if (event.Location?.DisplayName) {
+            console.log(`      Location: ${event.Location.DisplayName}`);
+          }
+          if (event.Organizer?.EmailAddress) {
+            const org = event.Organizer.EmailAddress;
+            console.log(`      Organizer: ${org.Name || org.Address}`);
+          }
+        }
+
+        console.log(`\n${'\u2500'.repeat(60)}`);
+        console.log('\nTo respond, use:');
+        console.log('  m365-agent-cli respond accept --id <eventId>');
+        console.log('  m365-agent-cli respond decline --id <eventId>');
+        console.log('  m365-agent-cli respond tentative --id <eventId>');
+        console.log('');
+        return;
+      }
+
+      // Handle accept/decline/tentative
+      if (!['accept', 'decline', 'tentative'].includes(actionLower)) {
+        console.error(`Unknown action: ${action}`);
+        console.error('Valid actions: list, accept, decline, tentative');
+        process.exit(1);
+      }
+
+      checkReadOnly(cmd);
+
+      if (!options.id) {
+        console.error('Please specify the event id with --id.');
+        console.error('Run `m365-agent-cli respond list` to see pending invitations and IDs.');
+        process.exit(1);
+      }
+
+      // Look up the event directly to check IsOrganizer (pendingEvents filters out organizer events)
+      const eventResult = await getCalendarEvent(authResult.token!, options.id, options.mailbox);
+      if (!eventResult.ok || !eventResult.data) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: `Invalid event id: ${options.id}` }, null, 2));
+        } else {
+          console.error(`Invalid event id: ${options.id}`);
+        }
+        process.exit(1);
+      }
+
+      if (eventResult.data.IsOrganizer) {
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                error:
+                  "You are the organizer of this meeting. Use 'm365-agent-cli update-event' instead to modify the meeting."
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          console.error(
+            "You are the organizer of this meeting. Use 'm365-agent-cli update-event' instead to modify the meeting."
+          );
+        }
+        process.exit(1);
+      }
+
+      const targetEvent = eventResult.data;
+
+      console.log(`\nResponding to: ${targetEvent.Subject}`);
+      console.log(
+        `  ${formatDate(targetEvent.Start.DateTime)} ${formatTime(targetEvent.Start.DateTime)} - ${formatTime(targetEvent.End.DateTime)}`
+      );
+      console.log(`  Action: ${actionLower}`);
+      if (options.comment) {
+        console.log(`  Comment: ${options.comment}`);
+      }
+      console.log('');
+
+      const response = await respondToEvent({
+        token: authResult.token!,
+        eventId: targetEvent.Id,
+        response: actionLower as ResponseType,
+        comment: options.comment,
+        sendResponse: options.notify,
+        mailbox: options.mailbox
+      });
+
+      if (!response.ok) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: response.error?.message || 'Failed to respond' }, null, 2));
+        } else {
+          console.error(`Error: ${response.error?.message || 'Failed to respond'}`);
+        }
+        process.exit(1);
+      }
+
+      const actionPast = actionLower === 'tentative' ? 'tentatively accepted' : `${actionLower}d`;
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, action: actionLower }, null, 2));
+      } else {
+        console.log(`\u2713 Successfully ${actionPast} the invitation.`);
+      }
+    }
+  );

package/src/commands/rooms.ts

@@ -0,0 +1,210 @@
+import { Command } from 'commander';
+import { resolveGraphAuth } from '../lib/graph-auth.js';
+import {
+  findRooms,
+  isRoomFree,
+  listPlaceRoomLists,
+  listRoomsInRoomList,
+  type Place,
+  type RoomFilters
+} from '../lib/places-client.js';
+
+function parseCapacityFilter(value: string | undefined): number | undefined {
+  if (!value) return undefined;
+  const cleaned = value.replaceAll('+', '').replaceAll('>', '').trim();
+  const parsed = parseInt(cleaned, 10);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`Invalid capacity value: "${value}". Must be a number.`);
+  }
+  return parsed;
+}
+
+function parseEquipmentFilter(value: string | undefined): string[] | undefined {
+  if (!value) return undefined;
+  return value
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+export const roomsCommand = new Command('rooms')
+  .description('Discover rooms and room lists via Microsoft Graph Places API')
+  .argument('[action]', 'Action: lists, rooms, or find')
+  .argument('[roomListEmail]', 'Room list email address (required for rooms action)')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific token')
+  .option('--building <name>', 'Filter by building name (for find action)')
+  .option('--capacity <num>', 'Minimum room capacity (for find action)')
+  .option('--equipment <items>', 'Required equipment tags, comma-separated (for find action)')
+  .option('--start <iso>', 'Start time ISO string (for find action)')
+  .option('--end <iso>', 'End time ISO string (for find action)')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .action(
+    async (
+      action: string,
+      roomListEmail: string | undefined,
+      options: {
+        json?: boolean;
+        token?: string;
+        identity?: string;
+        building?: string;
+        capacity?: string;
+        equipment?: string;
+        start?: string;
+        end?: string;
+      }
+    ) => {
+      const authResult = await resolveGraphAuth({ token: options.token, identity: options.identity });
+      if (!authResult.success) {
+        console.error(`Error: ${authResult.error}`);
+        process.exit(1);
+      }
+
+      if (action === 'lists' || action === undefined) {
+        console.log('Fetching room lists...');
+        const result = await listPlaceRoomLists({ token: authResult.token, identity: options.identity });
+        if (!result.ok || !result.data) {
+          console.error(`Error: ${result.error?.message || 'Failed to fetch room lists'}`);
+          process.exit(1);
+        }
+        const lists = result.data;
+        if (options.json) {
+          console.log(JSON.stringify({ roomLists: lists }, null, 2));
+          return;
+        }
+        if (lists.length === 0) {
+          console.log('No room lists found.');
+          return;
+        }
+        console.log(`\nRoom Lists (${lists.length}):\n`);
+        console.log('-'.repeat(70));
+        for (const list of lists) {
+          console.log(`  ${list.displayName || '(no name)'}`);
+          if (list.emailAddress) console.log(`    ${list.emailAddress}`);
+          console.log(`    ID: ${list.id}`);
+          console.log('');
+        }
+        console.log('-'.repeat(70));
+        console.log('\nTip: Use "m365-agent-cli rooms rooms <email>" to see rooms.\n');
+        return;
+      }
+
+      if (action === 'rooms') {
+        if (!roomListEmail) {
+          console.error('Error: rooms action requires a room list email address.');
+          console.error('Use "m365-agent-cli rooms lists" to see available room lists.');
+          process.exit(1);
+        }
+        console.log(`Fetching rooms from list: ${roomListEmail}...`);
+        const result = await listRoomsInRoomList(roomListEmail, {
+          token: authResult.token,
+          identity: options.identity
+        });
+        if (!result.ok || !result.data) {
+          console.error(`Error: ${result.error?.message || 'Failed to fetch rooms'}`);
+          process.exit(1);
+        }
+        const rooms = result.data;
+        if (options.json) {
+          console.log(JSON.stringify({ rooms }, null, 2));
+          return;
+        }
+        if (rooms.length === 0) {
+          console.log('No rooms found.');
+          return;
+        }
+        console.log(`\nRooms (${rooms.length}):\n`);
+        console.log('-'.repeat(70));
+        for (const room of rooms) {
+          console.log(`  ${room.displayName || '(no name)'}`);
+          if (room.emailAddress) console.log(`    ${room.emailAddress}`);
+          if (room.capacity) console.log(`    Capacity: ${room.capacity}`);
+          if (room.bookingType) console.log(`    Booking type: ${room.bookingType}`);
+          if (room.building) console.log(`    Building: ${room.building}`);
+          if (room.floorNumber !== undefined) console.log(`    Floor: ${room.floorNumber}`);
+          if (room.tags && room.tags.length > 0) console.log(`    Tags: ${room.tags.join(', ')}`);
+          console.log(`    ID: ${room.id}`);
+          console.log('');
+        }
+        console.log('-'.repeat(70));
+        return;
+      }
+
+      if (action === 'find') {
+        let filters: RoomFilters;
+        try {
+          filters = {
+            building: options.building,
+            capacityMin: parseCapacityFilter(options.capacity),
+            equipment: parseEquipmentFilter(options.equipment)
+          };
+        } catch (err) {
+          console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+          process.exit(1);
+        }
+        const hasFilters = !!(
+          filters.building ||
+          filters.capacityMin !== undefined ||
+          (filters.equipment && filters.equipment.length > 0)
+        );
+        if (!hasFilters) {
+          console.error('Error: find action requires at least one filter (--building, --capacity, or --equipment).');
+          process.exit(1);
+        }
+        console.log('Searching for rooms...');
+        const result = await findRooms(filters, { token: authResult.token, identity: options.identity });
+        if (!result.ok || !result.data) {
+          console.error(`Error: ${result.error?.message || 'Failed to search rooms'}`);
+          process.exit(1);
+        }
+        let availableRooms = result.data;
+        if (options.start && options.end) {
+          const freeRooms: Place[] = [];
+          let availabilityCheckFailed = false;
+          for (const room of availableRooms) {
+            if (room.emailAddress) {
+              const free = await isRoomFree(authResult.token!, room.emailAddress, options.start, options.end);
+              if (free === null) {
+                availabilityCheckFailed = true;
+                freeRooms.push(room);
+              } else if (free) {
+                freeRooms.push(room);
+              }
+            } else {
+              freeRooms.push(room);
+              availabilityCheckFailed = true;
+            }
+          }
+          availableRooms = freeRooms;
+          if (availabilityCheckFailed) {
+            console.warn(
+              'Warning: Could not check availability for some rooms (insufficient permissions or API error).'
+            );
+          }
+        }
+        if (options.json) {
+          console.log(JSON.stringify({ rooms: availableRooms }, null, 2));
+          return;
+        }
+        if (availableRooms.length === 0) {
+          console.log('No matching rooms found.');
+          return;
+        }
+        console.log(`\nMatching rooms (${availableRooms.length}):\n`);
+        for (const room of availableRooms) {
+          const tags = room.tags?.length ? ` [${room.tags.join(', ')}]` : '';
+          const cap = room.capacity ? ` (cap: ${room.capacity})` : '';
+          console.log(`  - ${room.displayName}${cap}${tags}`);
+          if (room.emailAddress) console.log(`    ${room.emailAddress}`);
+          if (room.building) console.log(`    Building: ${room.building}`);
+          console.log('');
+        }
+        return;
+      }
+
+      if (action !== undefined) {
+        console.error(`Unknown action: "${action}". Use "lists", "rooms", or "find".`);
+        process.exit(1);
+      }
+    }
+  );