nothumanallowed 4.1.0 → 5.0.0

package/src/config.mjs

@@ -52,6 +52,11 @@ const DEFAULT_CONFIG = {
     clientId: '',
     clientSecret: '',
   },
+  microsoft: {
+    clientId: '',
+    clientSecret: '',
+    tenantId: 'common',
+  },
   ops: {
     enabled: false,
     planTime: '07:00',
@@ -68,6 +73,15 @@ const DEFAULT_CONFIG = {
       terminal: true,
     },
   },
+  plugins: {
+    autoRun: true,
+    directory: '',
+  },
+  voice: {
+    preferWhisper: false,
+    speechSynthesis: true,
+    language: '',
+  },
 };
 
 /**
@@ -174,11 +188,20 @@ export function setConfigValue(key, value) {
     'knowledge': 'features.knowledgeEnabled',
     'google-client-id': 'google.clientId',
     'google-client-secret': 'google.clientSecret',
+    'microsoft-client-id': 'microsoft.clientId',
+    'microsoft-client-secret': 'microsoft.clientSecret',
+    'microsoft-tenant': 'microsoft.tenantId',
+    'microsoft-tenant-id': 'microsoft.tenantId',
     'plan-time': 'ops.planTime',
     'summary-time': 'ops.summaryTime',
     'meeting-alert': 'ops.meetingAlertMinutes',
     'telegram-webhook': 'ops.webhooks.telegram',
     'discord-webhook': 'ops.webhooks.discord',
+    'plugin-autorun': 'plugins.autoRun',
+    'plugin-dir': 'plugins.directory',
+    'voice-whisper': 'voice.preferWhisper',
+    'voice-speech': 'voice.speechSynthesis',
+    'voice-language': 'voice.language',
   };
 
   const resolved = aliases[key] || key;

package/src/constants.mjs

@@ -1,7 +1,7 @@
 import os from 'os';
 import path from 'path';
 
-export const VERSION = '3.1.0';
+export const VERSION = '5.0.0';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 
@@ -9,6 +9,7 @@ export const NHA_DIR = path.join(os.homedir(), '.nha');
 export const CORE_DIR = path.join(NHA_DIR, 'core');
 export const AGENTS_DIR = path.join(NHA_DIR, 'agents');
 export const EXTENSIONS_DIR = path.join(NHA_DIR, 'extensions');
+export const PLUGINS_DIR = path.join(NHA_DIR, 'plugins');
 export const SESSIONS_DIR = path.join(NHA_DIR, 'sessions');
 export const MEMORY_DIR = path.join(NHA_DIR, 'memory');
 export const CONFIG_FILE = path.join(NHA_DIR, 'config.json');

package/src/services/mail-router.mjs

@@ -0,0 +1,298 @@
+/**
+ * Unified Mail + Calendar router — routes to Google or Microsoft based on auth state.
+ *
+ * Detects which provider is authenticated and routes all mail/calendar calls
+ * through the appropriate service. If both are authenticated, prefers the
+ * provider specified in config, falling back to the first authenticated one.
+ *
+ * All functions return the same unified data shapes defined by google-gmail.mjs
+ * and google-calendar.mjs parsers (Microsoft services normalize to the same shape).
+ *
+ * Zero dependencies — pure routing layer.
+ */
+
+import { getAuthenticatedProviders, loadTokens } from './token-store.mjs';
+
+// Lazy imports to avoid loading both provider modules at startup
+let _google = null;
+let _microsoft = null;
+let _googleCal = null;
+let _microsoftCal = null;
+
+async function getGoogleMail() {
+  if (!_google) _google = await import('./google-gmail.mjs');
+  return _google;
+}
+
+async function getMicrosoftMail() {
+  if (!_microsoft) _microsoft = await import('./microsoft-mail.mjs');
+  return _microsoft;
+}
+
+async function getGoogleCalendar() {
+  if (!_googleCal) _googleCal = await import('./google-calendar.mjs');
+  return _googleCal;
+}
+
+async function getMicrosoftCalendar() {
+  if (!_microsoftCal) _microsoftCal = await import('./microsoft-calendar.mjs');
+  return _microsoftCal;
+}
+
+/**
+ * Determine which mail provider to use.
+ * @param {object} config — NHA config
+ * @returns {'google' | 'microsoft' | null}
+ */
+export function detectMailProvider(config) {
+  const providers = getAuthenticatedProviders();
+
+  // If a preferred provider is set in config and authenticated, use it
+  const preferred = config.ops?.mailProvider;
+  if (preferred && providers[preferred]) return preferred;
+
+  // Otherwise, use whichever is authenticated (Google first for backward compat)
+  if (providers.google) return 'google';
+  if (providers.microsoft) return 'microsoft';
+
+  return null;
+}
+
+/**
+ * Check if any mail provider is authenticated.
+ */
+export function hasMailProvider() {
+  const providers = getAuthenticatedProviders();
+  return providers.google || providers.microsoft;
+}
+
+/**
+ * Get authentication status for display purposes.
+ */
+export function getProviderStatus() {
+  const providers = getAuthenticatedProviders();
+  const result = [];
+
+  if (providers.google) {
+    const tokens = loadTokens('google');
+    result.push({ provider: 'google', email: tokens?.email || 'unknown', active: true });
+  }
+  if (providers.microsoft) {
+    const tokens = loadTokens('microsoft');
+    result.push({ provider: 'microsoft', email: tokens?.email || 'unknown', active: true });
+  }
+
+  return result;
+}
+
+// ── Mail Functions ─────────────────────────────────────────────────────────
+
+/**
+ * List messages matching a query.
+ */
+export async function listMessages(config, query = '', maxResults = 20) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated. Run: nha google auth OR nha microsoft auth');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.listMessages(config, query, maxResults);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.listMessages(config, query || 'is:unread', maxResults);
+}
+
+/**
+ * Get a full message by ID.
+ */
+export async function getMessage(config, messageId) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.getMessage(config, messageId);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.getMessage(config, messageId);
+}
+
+/**
+ * Get unread important emails (for daily planner).
+ */
+export async function getUnreadImportant(config, maxResults = 30) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.getUnreadImportant(config, maxResults);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.getUnreadImportant(config, maxResults);
+}
+
+/**
+ * Get today's emails.
+ */
+export async function getTodayEmails(config, maxResults = 50) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.getTodayEmails(config, maxResults);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.getTodayEmails(config, maxResults);
+}
+
+/**
+ * Send an email.
+ */
+export async function sendEmail(config, to, subject, body, opts = {}) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.sendEmail(config, to, subject, body, opts);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.sendEmail(config, to, subject, body, opts);
+}
+
+/**
+ * Create a draft email.
+ */
+export async function createDraft(config, to, subject, body) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.createDraft(config, to, subject, body);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.createDraft(config, to, subject, body);
+}
+
+/**
+ * Get user's email profile.
+ */
+export async function getProfile(config) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftMail();
+    return ms.getProfile(config);
+  }
+
+  const gm = await getGoogleMail();
+  return gm.getProfile(config);
+}
+
+// ── Calendar Functions ────────────────────────────────────────────────────
+
+/**
+ * Get today's events from all calendars.
+ */
+export async function getTodayEvents(config) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.getTodayEvents(config);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.getTodayEvents(config);
+}
+
+/**
+ * Get upcoming events (next N hours).
+ */
+export async function getUpcomingEvents(config, hours = 2) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.getUpcomingEvents(config, hours);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.getUpcomingEvents(config, hours);
+}
+
+/**
+ * Get events for a specific date.
+ */
+export async function getEventsForDate(config, date) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.getEventsForDate(config, date);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.getEventsForDate(config, date);
+}
+
+/**
+ * Create a new calendar event.
+ */
+export async function createEvent(config, event, calendarId = 'primary') {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.createEvent(config, event, calendarId);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.createEvent(config, event, calendarId);
+}
+
+/**
+ * Update an existing calendar event.
+ */
+export async function updateEvent(config, calendarId, eventId, patch) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.updateEvent(config, calendarId, eventId, patch);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.updateEvent(config, calendarId, eventId, patch);
+}
+
+/**
+ * List events for a date range.
+ */
+export async function listEvents(config, calendarId = 'primary', timeMin, timeMax) {
+  const provider = detectMailProvider(config);
+  if (!provider) throw new Error('No mail provider authenticated.');
+
+  if (provider === 'microsoft') {
+    const ms = await getMicrosoftCalendar();
+    return ms.listEvents(config, calendarId, timeMin, timeMax);
+  }
+
+  const gc = await getGoogleCalendar();
+  return gc.listEvents(config, calendarId, timeMin, timeMax);
+}

package/src/services/microsoft-calendar.mjs

@@ -0,0 +1,319 @@
+/**
+ * Outlook Calendar API wrapper via Microsoft Graph — zero dependencies.
+ * All calls via native fetch to Microsoft Graph REST API.
+ *
+ * Output format matches google-calendar.mjs parsed shape for unified consumption.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { getMicrosoftAccessToken } from './microsoft-oauth.mjs';
+import { NHA_DIR } from '../constants.mjs';
+
+const GRAPH_BASE = 'https://graph.microsoft.com/v1.0/me';
+const CAL_DIR = path.join(NHA_DIR, 'ops', 'calendar');
+
+/** Authenticated fetch with auto-retry on 401 */
+async function graphFetch(config, urlPath, options = {}) {
+  const token = await getMicrosoftAccessToken(config);
+  const url = urlPath.startsWith('http') ? urlPath : `${GRAPH_BASE}${urlPath}`;
+
+  let res = await fetch(url, {
+    ...options,
+    headers: {
+      ...options.headers,
+      'Authorization': `Bearer ${token}`,
+      'Prefer': 'outlook.timezone="' + Intl.DateTimeFormat().resolvedOptions().timeZone + '"',
+    },
+  });
+
+  if (res.status === 401) {
+    const newToken = await getMicrosoftAccessToken(config);
+    res = await fetch(url, {
+      ...options,
+      headers: {
+        ...options.headers,
+        'Authorization': `Bearer ${newToken}`,
+        'Prefer': 'outlook.timezone="' + Intl.DateTimeFormat().resolvedOptions().timeZone + '"',
+      },
+    });
+  }
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Microsoft Calendar API ${res.status}: ${err}`);
+  }
+
+  return res.json();
+}
+
+/**
+ * List all calendars the user has access to.
+ */
+export async function listCalendars(config) {
+  const data = await graphFetch(config, '/calendars');
+  return (data.value || []).map(c => ({
+    id: c.id,
+    summary: c.name,
+    primary: c.isDefaultCalendar || false,
+    timeZone: c.owner?.address ? undefined : undefined, // Graph doesn't expose per-calendar TZ the same way
+    accessRole: c.canEdit ? 'writer' : 'reader',
+  }));
+}
+
+/**
+ * List events for a date range.
+ * @param {object} config
+ * @param {string} calendarId — calendar ID or 'primary' for default
+ * @param {Date} timeMin
+ * @param {Date} timeMax
+ * @returns {Promise<Array>} parsed events
+ */
+export async function listEvents(config, calendarId = 'primary', timeMin, timeMax) {
+  const calPath = calendarId === 'primary'
+    ? '/calendar/calendarView'
+    : `/calendars/${calendarId}/calendarView`;
+
+  const params = new URLSearchParams({
+    startDateTime: timeMin.toISOString(),
+    endDateTime: timeMax.toISOString(),
+    '$top': '50',
+    '$orderby': 'start/dateTime',
+    '$select': 'id,subject,body,location,start,end,isAllDay,attendees,organizer,onlineMeeting,webLink,showAs,responseStatus',
+  });
+
+  const data = await graphFetch(config, `${calPath}?${params}`);
+  const events = (data.value || []).map(parseEvent);
+
+  // Cache events
+  cacheEvents(timeMin, events);
+  return events;
+}
+
+/**
+ * Get today's events from all calendars.
+ */
+export async function getTodayEvents(config) {
+  const now = new Date();
+  const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const endOfDay = new Date(startOfDay.getTime() + 86400000);
+
+  const calendars = await listCalendars(config);
+  const allEvents = [];
+
+  for (const cal of calendars) {
+    try {
+      const events = await listEvents(config, cal.id, startOfDay, endOfDay);
+      for (const e of events) {
+        e.calendarName = cal.summary;
+        allEvents.push(e);
+      }
+    } catch { /* skip failed calendars */ }
+  }
+
+  // Sort by start time
+  allEvents.sort((a, b) => new Date(a.start).getTime() - new Date(b.start).getTime());
+  return allEvents;
+}
+
+/**
+ * Get events for a specific date.
+ */
+export async function getEventsForDate(config, date) {
+  const d = new Date(date);
+  const startOfDay = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+  const endOfDay = new Date(startOfDay.getTime() + 86400000);
+  return listEvents(config, 'primary', startOfDay, endOfDay);
+}
+
+/**
+ * Get upcoming events (next N hours).
+ * @param {number} hours — look-ahead hours (default 2)
+ */
+export async function getUpcomingEvents(config, hours = 2) {
+  const now = new Date();
+  const end = new Date(now.getTime() + hours * 3600000);
+  return listEvents(config, 'primary', now, end);
+}
+
+/**
+ * Create a new event.
+ * @param {object} config
+ * @param {object} event — { summary, start, end, description, location, attendees }
+ * @param {string} calendarId
+ */
+export async function createEvent(config, event, calendarId = 'primary') {
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+  const startStr = String(event.start);
+  const endStr = String(event.end);
+
+  // Normalize datetime — Microsoft Graph expects ISO format or { dateTime, timeZone }
+  const startDT = (startStr.endsWith('Z') || /[+-]\d{2}:\d{2}$/.test(startStr))
+    ? new Date(startStr).toISOString().replace('Z', '')
+    : startStr;
+  const endDT = (endStr.endsWith('Z') || /[+-]\d{2}:\d{2}$/.test(endStr))
+    ? new Date(endStr).toISOString().replace('Z', '')
+    : endStr;
+
+  const body = {
+    subject: event.summary,
+    body: {
+      contentType: 'Text',
+      content: event.description || '',
+    },
+    start: { dateTime: startDT, timeZone: tz },
+    end: { dateTime: endDT, timeZone: tz },
+  };
+
+  if (event.location) {
+    body.location = { displayName: event.location };
+  }
+
+  if (event.attendees?.length) {
+    body.attendees = event.attendees.map(email => ({
+      emailAddress: { address: email },
+      type: 'required',
+    }));
+  }
+
+  const calPath = calendarId === 'primary'
+    ? '/calendar/events'
+    : `/calendars/${calendarId}/events`;
+
+  return graphFetch(config, calPath, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+}
+
+/**
+ * Update an existing event (partial).
+ */
+export async function updateEvent(config, calendarId, eventId, patch) {
+  // Translate Google-style patch to Microsoft Graph format
+  const body = {};
+
+  if (patch.summary) body.subject = patch.summary;
+  if (patch.description) body.body = { contentType: 'Text', content: patch.description };
+  if (patch.location) body.location = { displayName: patch.location };
+
+  if (patch.start) {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (typeof patch.start === 'object' && patch.start.dateTime) {
+      body.start = { dateTime: patch.start.dateTime.replace('Z', ''), timeZone: tz };
+    } else {
+      body.start = { dateTime: new Date(patch.start).toISOString().replace('Z', ''), timeZone: tz };
+    }
+  }
+
+  if (patch.end) {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (typeof patch.end === 'object' && patch.end.dateTime) {
+      body.end = { dateTime: patch.end.dateTime.replace('Z', ''), timeZone: tz };
+    } else {
+      body.end = { dateTime: new Date(patch.end).toISOString().replace('Z', ''), timeZone: tz };
+    }
+  }
+
+  const calPath = calendarId === 'primary'
+    ? `/calendar/events/${eventId}`
+    : `/calendars/${calendarId}/events/${eventId}`;
+
+  return graphFetch(config, calPath, {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+}
+
+// ── Event Parser ───────────────────────────────────────────────────────────
+
+/**
+ * Parse Microsoft Graph event to unified format matching Google Calendar output.
+ */
+function parseEvent(raw) {
+  const isAllDay = raw.isAllDay || false;
+
+  // Microsoft returns { dateTime, timeZone } objects for start/end
+  let start = '';
+  let end = '';
+
+  if (isAllDay) {
+    // All-day events: use date portion only (YYYY-MM-DD)
+    start = raw.start?.dateTime?.split('T')[0] || '';
+    end = raw.end?.dateTime?.split('T')[0] || '';
+  } else {
+    // Timed events: use full ISO datetime
+    start = raw.start?.dateTime || '';
+    end = raw.end?.dateTime || '';
+  }
+
+  // Build online meeting link (Teams or other)
+  const meetingLink = raw.onlineMeeting?.joinUrl || '';
+
+  return {
+    id: raw.id,
+    summary: raw.subject || '(no title)',
+    description: raw.body?.content
+      ? raw.body.content
+          .replace(/<[^>]+>/g, ' ')
+          .replace(/&nbsp;/g, ' ')
+          .replace(/\s+/g, ' ')
+          .trim()
+          .slice(0, 2000)
+      : '',
+    location: raw.location?.displayName || '',
+    start,
+    end,
+    isAllDay,
+    status: raw.showAs || 'busy',
+    attendees: (raw.attendees || []).map(a => ({
+      email: a.emailAddress?.address || '',
+      name: a.emailAddress?.name || '',
+      responseStatus: mapResponseStatus(a.status?.response),
+      self: false,
+    })),
+    organizer: raw.organizer?.emailAddress?.address || '',
+    hangoutLink: meetingLink, // unified field for any online meeting link
+    htmlLink: raw.webLink || '',
+    calendarName: '',
+    provider: 'microsoft',
+  };
+}
+
+/**
+ * Map Microsoft response status to Google-compatible values.
+ */
+function mapResponseStatus(msStatus) {
+  const map = {
+    none: 'needsAction',
+    organizer: 'accepted',
+    tentativelyAccepted: 'tentative',
+    accepted: 'accepted',
+    declined: 'declined',
+    notResponded: 'needsAction',
+  };
+  return map[msStatus] || 'needsAction';
+}
+
+// ── Local Cache ────────────────────────────────────────────────────────────
+
+function cacheEvents(date, events) {
+  fs.mkdirSync(CAL_DIR, { recursive: true });
+  const dateStr = date instanceof Date ? date.toISOString().split('T')[0] : String(date);
+  const file = path.join(CAL_DIR, `ms-events-${dateStr}.json`);
+  fs.writeFileSync(file, JSON.stringify(events, null, 2), { mode: 0o600 });
+}
+
+/**
+ * Load cached events for a date.
+ */
+export function loadCachedEvents(date) {
+  const dateStr = date instanceof Date ? date.toISOString().split('T')[0] : String(date);
+  const file = path.join(CAL_DIR, `ms-events-${dateStr}.json`);
+  if (!fs.existsSync(file)) return null;
+  try { return JSON.parse(fs.readFileSync(file, 'utf-8')); }
+  catch { return null; }
+}