m365-cli 0.1.0

package/src/auth/token-manager.js

@@ -0,0 +1,237 @@
+import { readFileSync, writeFileSync, mkdirSync, chmodSync, unlinkSync } from 'fs';
+import { dirname, join } from 'path';
+import config from '../utils/config.js';
+import { AuthError, TokenExpiredError } from '../utils/error.js';
+import { deviceCodeFlow } from './device-flow.js';
+
+/**
+ * Token Manager
+ * Handles token storage, refresh, and validation
+ */
+
+/**
+ * Load credentials from file
+ * Supports migration from old token file
+ */
+export function loadCreds() {
+  const credsPath = config.getCredsPath();
+  const oldTokenPath = join(dirname(credsPath), '../.m365-token.json');
+  
+  // Try to load from new creds file
+  try {
+    const data = readFileSync(credsPath, 'utf-8');
+    const creds = JSON.parse(data);
+    
+    // Validate it's a proper JSON object
+    if (creds && typeof creds === 'object' && creds.accessToken) {
+      return creds;
+    }
+  } catch (error) {
+    // File doesn't exist or not valid JSON, continue to migration
+  }
+  
+  // Try to migrate from old token file
+  try {
+    const oldData = readFileSync(oldTokenPath, 'utf-8');
+    const oldToken = JSON.parse(oldData);
+    
+    if (oldToken && oldToken.access_token) {
+      // Migrate to new format
+      const creds = {
+        tenantId: config.get('tenantId'),
+        clientId: config.get('clientId'),
+        accessToken: oldToken.access_token,
+        refreshToken: oldToken.refresh_token,
+        expiresAt: oldToken.expires_at,
+      };
+      
+      // Save to new location
+      saveCreds(creds);
+      
+      console.log('ℹ️  Migrated token from old format.');
+      
+      return creds;
+    }
+  } catch (error) {
+    // Old file doesn't exist either
+  }
+  
+  return null; // No credentials found
+}
+
+/**
+ * Save credentials to file
+ */
+export function saveCreds(creds) {
+  const credsPath = config.getCredsPath();
+  
+  try {
+    // Ensure directory exists
+    mkdirSync(dirname(credsPath), { recursive: true });
+    
+    // Write credentials
+    writeFileSync(credsPath, JSON.stringify(creds, null, 2), 'utf-8');
+    
+    // Set permissions to 600 (user read/write only)
+    chmodSync(credsPath, 0o600);
+  } catch (error) {
+    throw new AuthError(`Failed to save credentials: ${error.message}`);
+  }
+}
+
+/**
+ * Check if token is expired
+ */
+export function isTokenExpired(creds) {
+  if (!creds || !creds.expiresAt) {
+    return true;
+  }
+  
+  const now = Math.floor(Date.now() / 1000);
+  const buffer = config.get('tokenRefreshBuffer') || 60;
+  
+  return creds.expiresAt <= (now + buffer);
+}
+
+/**
+ * Refresh access token using refresh token
+ */
+export async function refreshToken(refreshToken) {
+  const tenantId = config.get('tenantId');
+  const clientId = config.get('clientId');
+  const scopes = config.get('scopes').join(' ');
+  const authUrl = config.get('authUrl');
+  
+  const url = `${authUrl}/${tenantId}/oauth2/v2.0/token`;
+  
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: new URLSearchParams({
+        client_id: clientId,
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+        scope: scopes,
+      }),
+    });
+    
+    if (!response.ok) {
+      const error = await response.json();
+      throw new AuthError(
+        error.error_description || 'Token refresh failed',
+        error
+      );
+    }
+    
+    const data = await response.json();
+    
+    return {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token || refreshToken,
+      expiresIn: data.expires_in || 3600,
+    };
+  } catch (error) {
+    if (error instanceof AuthError) {
+      throw error;
+    }
+    throw new AuthError(`Failed to refresh token: ${error.message}`);
+  }
+}
+
+/**
+ * Get valid access token (auto-refresh if needed)
+ */
+export async function getAccessToken() {
+  const creds = loadCreds();
+  
+  if (!creds || !creds.accessToken) {
+    throw new AuthError('Not authenticated. Please run: m365 login');
+  }
+  
+  // Check if token is expired
+  if (!isTokenExpired(creds)) {
+    return creds.accessToken;
+  }
+  
+  // Try to refresh
+  if (!creds.refreshToken) {
+    throw new TokenExpiredError();
+  }
+  
+  try {
+    const refreshed = await refreshToken(creds.refreshToken);
+    
+    // Save new credentials
+    const newCreds = {
+      tenantId: config.get('tenantId'),
+      clientId: config.get('clientId'),
+      accessToken: refreshed.accessToken,
+      refreshToken: refreshed.refreshToken,
+      expiresAt: Math.floor(Date.now() / 1000) + refreshed.expiresIn,
+    };
+    
+    saveCreds(newCreds);
+    
+    return refreshed.accessToken;
+  } catch (error) {
+    throw new TokenExpiredError();
+  }
+}
+
+/**
+ * Perform login (device code flow)
+ */
+export async function login() {
+  try {
+    const result = await deviceCodeFlow();
+    
+    const creds = {
+      tenantId: config.get('tenantId'),
+      clientId: config.get('clientId'),
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken,
+      expiresAt: Math.floor(Date.now() / 1000) + result.expiresIn,
+    };
+    
+    saveCreds(creds);
+    
+    console.log('\n✅ Authentication successful!');
+    console.log(`   Credentials saved to: ${config.getCredsPath()}`);
+    
+    return true;
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Logout (clear credentials)
+ */
+export function logout() {
+  const credsPath = config.getCredsPath();
+  
+  try {
+    unlinkSync(credsPath);
+    console.log('✅ Logged out successfully.');
+    return true;
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.log('ℹ️  No credentials found.');
+      return true;
+    }
+    throw new AuthError(`Failed to logout: ${error.message}`);
+  }
+}
+
+export default {
+  loadCreds,
+  saveCreds,
+  isTokenExpired,
+  refreshToken,
+  getAccessToken,
+  login,
+  logout,
+};

package/src/commands/calendar.js

@@ -0,0 +1,279 @@
+import graphClient from '../graph/client.js';
+import { outputCalendarList, outputCalendarDetail, outputCalendarResult } from '../utils/output.js';
+import { handleError } from '../utils/error.js';
+
+/**
+ * Calendar commands
+ */
+
+/**
+ * List calendar events
+ */
+export async function listEvents(options) {
+  try {
+    const { days = 7, top = 50, json = false } = options;
+    
+    // Calculate date range
+    const startDateTime = new Date();
+    const endDateTime = new Date();
+    endDateTime.setDate(endDateTime.getDate() + days);
+    
+    const events = await graphClient.calendar.list({
+      startDateTime: startDateTime.toISOString(),
+      endDateTime: endDateTime.toISOString(),
+      top,
+    });
+    
+    outputCalendarList(events, { json, days });
+  } catch (error) {
+    handleError(error, { json: options.json });
+  }
+}
+
+/**
+ * Get calendar event by ID
+ */
+export async function getEvent(id, options) {
+  try {
+    const { json = false } = options;
+    
+    if (!id) {
+      throw new Error('Event ID is required');
+    }
+    
+    const event = await graphClient.calendar.get(id);
+    
+    outputCalendarDetail(event, { json });
+  } catch (error) {
+    handleError(error, { json: options.json });
+  }
+}
+
+/**
+ * Create calendar event
+ */
+export async function createEvent(title, options) {
+  try {
+    const {
+      start,
+      end,
+      location = '',
+      body = '',
+      attendees = [],
+      allday = false,
+      json = false,
+    } = options;
+    
+    if (!title) {
+      throw new Error('Event title is required');
+    }
+    
+    if (!start || !end) {
+      throw new Error('Start and end time are required');
+    }
+    
+    // Parse datetime strings
+    let startDateTime, endDateTime;
+    
+    if (allday) {
+      // All-day events use date only (YYYY-MM-DD)
+      startDateTime = start.includes('T') ? start.split('T')[0] : start;
+      endDateTime = end.includes('T') ? end.split('T')[0] : end;
+    } else {
+      // Regular events use full datetime
+      startDateTime = start.includes('T') ? start : `${start}T00:00:00`;
+      endDateTime = end.includes('T') ? end : `${end}T00:00:00`;
+    }
+    
+    // Build event object
+    const event = {
+      subject: title,
+      start: {
+        dateTime: startDateTime,
+        timeZone: 'Asia/Shanghai',
+      },
+      end: {
+        dateTime: endDateTime,
+        timeZone: 'Asia/Shanghai',
+      },
+      isAllDay: allday,
+    };
+    
+    // Add location if provided
+    if (location) {
+      event.location = {
+        displayName: location,
+      };
+    }
+    
+    // Add body if provided
+    if (body) {
+      event.body = {
+        contentType: 'HTML',
+        content: body,
+      };
+    }
+    
+    // Add attendees if provided
+    if (attendees && attendees.length > 0) {
+      event.attendees = attendees.map(email => ({
+        emailAddress: {
+          address: email.trim(),
+        },
+        type: 'required',
+      }));
+    }
+    
+    // Create event
+    const created = await graphClient.calendar.create(event);
+    
+    // Build result with properly formatted times
+    // Note: Graph API returns dateTime in the specified timeZone, but without zone suffix
+    // We need to add the timezone suffix for correct display
+    const getTimeWithZone = (timeObj) => {
+      const tz = timeObj.timeZone;
+      if (tz === 'Asia/Shanghai') {
+        return timeObj.dateTime + '+08:00';
+      } else if (tz === 'UTC') {
+        return timeObj.dateTime + 'Z';
+      } else {
+        // For other timezones, use as-is (may not display correctly)
+        return timeObj.dateTime;
+      }
+    };
+    
+    const result = {
+      status: 'created',
+      id: created.id,
+      subject: created.subject,
+      start: getTimeWithZone(created.start),
+      end: getTimeWithZone(created.end),
+    };
+    
+    outputCalendarResult(result, { json });
+  } catch (error) {
+    handleError(error, { json: options.json });
+  }
+}
+
+/**
+ * Update calendar event
+ */
+export async function updateEvent(id, options) {
+  try {
+    const {
+      title,
+      start,
+      end,
+      location,
+      body,
+      json = false,
+    } = options;
+    
+    if (!id) {
+      throw new Error('Event ID is required');
+    }
+    
+    // Build update object (only include fields that are provided)
+    const updates = {};
+    
+    if (title) {
+      updates.subject = title;
+    }
+    
+    if (start) {
+      const startDateTime = start.includes('T') ? start : `${start}T00:00:00`;
+      updates.start = {
+        dateTime: startDateTime,
+        timeZone: 'Asia/Shanghai',
+      };
+    }
+    
+    if (end) {
+      const endDateTime = end.includes('T') ? end : `${end}T00:00:00`;
+      updates.end = {
+        dateTime: endDateTime,
+        timeZone: 'Asia/Shanghai',
+      };
+    }
+    
+    if (location !== undefined) {
+      updates.location = {
+        displayName: location,
+      };
+    }
+    
+    if (body !== undefined) {
+      updates.body = {
+        contentType: 'HTML',
+        content: body,
+      };
+    }
+    
+    if (Object.keys(updates).length === 0) {
+      throw new Error('No updates provided. Use --title, --start, --end, --location, or --body');
+    }
+    
+    // Update event
+    const updated = await graphClient.calendar.update(id, updates);
+    
+    // Build result with properly formatted times
+    // Note: Graph API returns dateTime in the specified timeZone, but without zone suffix
+    // We need to add the timezone suffix for correct display
+    const getTimeWithZone = (timeObj) => {
+      const tz = timeObj.timeZone;
+      if (tz === 'Asia/Shanghai') {
+        return timeObj.dateTime + '+08:00';
+      } else if (tz === 'UTC') {
+        return timeObj.dateTime + 'Z';
+      } else {
+        // For other timezones, use as-is (may not display correctly)
+        return timeObj.dateTime;
+      }
+    };
+    
+    const result = {
+      status: 'updated',
+      id: updated.id,
+      subject: updated.subject,
+      start: getTimeWithZone(updated.start),
+      end: getTimeWithZone(updated.end),
+    };
+    
+    outputCalendarResult(result, { json });
+  } catch (error) {
+    handleError(error, { json: options.json });
+  }
+}
+
+/**
+ * Delete calendar event
+ */
+export async function deleteEvent(id, options) {
+  try {
+    const { json = false } = options;
+    
+    if (!id) {
+      throw new Error('Event ID is required');
+    }
+    
+    await graphClient.calendar.delete(id);
+    
+    const result = {
+      status: 'deleted',
+      id,
+    };
+    
+    outputCalendarResult(result, { json });
+  } catch (error) {
+    handleError(error, { json: options.json });
+  }
+}
+
+export default {
+  list: listEvents,
+  get: getEvent,
+  create: createEvent,
+  update: updateEvent,
+  delete: deleteEvent,
+};