nothumanallowed 4.1.0 → 6.0.0

package/src/services/ops-pipeline.mjs

@@ -15,10 +15,10 @@
 import fs from 'fs';
 import path from 'path';
 import { callAgent, callLLM } from './llm.mjs';
-import { getUnreadImportant, getTodayEmails } from './google-gmail.mjs';
-import { getTodayEvents, getUpcomingEvents } from './google-calendar.mjs';
+import { getUnreadImportant, getTodayEmails } from './mail-router.mjs';
+import { getTodayEvents, getUpcomingEvents } from './mail-router.mjs';
 import { getTasks, bulkAddTasks } from './task-store.mjs';
-import { loadTokens } from './token-store.mjs';
+import { hasMailProvider } from './mail-router.mjs';
 import { NHA_DIR } from '../constants.mjs';
 import { info, ok, fail, warn, D, C, G, Y, W, BOLD, NC } from '../ui.mjs';
 
@@ -47,8 +47,7 @@ export async function runPlanningPipeline(config, opts = {}) {
   }
 
   const startTime = Date.now();
-  const tokens = loadTokens();
-  const hasGoogle = !!tokens;
+  const hasMail = hasMailProvider();
 
   console.log(`\n  ${BOLD}NHA Daily Plan — ${dateStr}${NC}`);
   console.log(`  ${D}5 specialist agents analyzing your day${NC}\n`);
@@ -60,7 +59,7 @@ export async function runPlanningPipeline(config, opts = {}) {
   let events = [];
   const tasks = getTasks(dateStr);
 
-  if (hasGoogle) {
+  if (hasMail) {
     try {
       [emails, events] = await Promise.all([
         getUnreadImportant(config, 30),
@@ -68,11 +67,11 @@ export async function runPlanningPipeline(config, opts = {}) {
       ]);
       ok(`${emails.length} emails, ${events.length} events, ${tasks.length} tasks`);
     } catch (err) {
-      warn(`Google API error: ${err.message}`);
+      warn(`Mail API error: ${err.message}`);
       info('Continuing with tasks only...');
     }
   } else {
-    warn('Google not connected. Using tasks only. Run "nha google auth" to connect.');
+    warn('No mail provider connected. Using tasks only. Run "nha google auth" or "nha microsoft auth" to connect.');
   }
 
   // Build context for agents

package/src/services/token-store.mjs

@@ -1,6 +1,8 @@
 /**
  * Encrypted token storage — AES-256-GCM with machine-derived key.
- * Stores OAuth tokens at ~/.nha/ops/tokens.enc
+ * Supports multiple providers (google, microsoft) via separate encrypted files.
+ * Stores OAuth tokens at ~/.nha/ops/tokens-<provider>.enc
+ * Legacy single-file (~/.nha/ops/tokens.enc) is treated as 'google' for backward compat.
  * Zero dependencies — uses Node.js native crypto.
  */
 
@@ -11,7 +13,15 @@ import path from 'path';
 import { NHA_DIR } from '../constants.mjs';
 
 const OPS_DIR = path.join(NHA_DIR, 'ops');
-const TOKENS_FILE = path.join(OPS_DIR, 'tokens.enc');
+const LEGACY_TOKENS_FILE = path.join(OPS_DIR, 'tokens.enc');
+
+/** Get tokens file path for a given provider */
+function getTokensFile(provider) {
+  if (!provider || provider === 'google') {
+    return LEGACY_TOKENS_FILE; // backward compatible — Google uses the original file
+  }
+  return path.join(OPS_DIR, `tokens-${provider}.enc`);
+}
 
 /** Derive encryption key from machine-specific fingerprint */
 function deriveKey() {
@@ -49,21 +59,25 @@ function decrypt(envelope) {
 /**
  * Save OAuth tokens (encrypted).
  * @param {object} tokens — { access_token, refresh_token, expires_at, scope, email }
+ * @param {string} provider — 'google' (default) or 'microsoft'
  */
-export function saveTokens(tokens) {
+export function saveTokens(tokens, provider) {
   fs.mkdirSync(OPS_DIR, { recursive: true });
+  const file = getTokensFile(provider);
   const envelope = encrypt(tokens);
-  fs.writeFileSync(TOKENS_FILE, JSON.stringify(envelope, null, 2), { mode: 0o600 });
+  fs.writeFileSync(file, JSON.stringify(envelope, null, 2), { mode: 0o600 });
 }
 
 /**
  * Load OAuth tokens (decrypted).
+ * @param {string} provider — 'google' (default) or 'microsoft'
  * @returns {object|null} tokens or null if not stored
  */
-export function loadTokens() {
-  if (!fs.existsSync(TOKENS_FILE)) return null;
+export function loadTokens(provider) {
+  const file = getTokensFile(provider);
+  if (!fs.existsSync(file)) return null;
   try {
-    const envelope = JSON.parse(fs.readFileSync(TOKENS_FILE, 'utf-8'));
+    const envelope = JSON.parse(fs.readFileSync(file, 'utf-8'));
     return decrypt(envelope);
   } catch {
     return null;
@@ -72,9 +86,11 @@ export function loadTokens() {
 
 /**
  * Delete stored tokens.
+ * @param {string} provider — 'google' (default) or 'microsoft'
  */
-export function deleteTokens() {
-  if (fs.existsSync(TOKENS_FILE)) fs.rmSync(TOKENS_FILE);
+export function deleteTokens(provider) {
+  const file = getTokensFile(provider);
+  if (fs.existsSync(file)) fs.rmSync(file);
 }
 
 /**
@@ -88,7 +104,7 @@ export function isExpired(tokens) {
 }
 
 /**
- * Refresh access token using refresh_token.
+ * Refresh access token using refresh_token (Google-specific).
  * @param {string} clientId
  * @param {string} clientSecret
  * @param {string} refreshToken
@@ -123,12 +139,12 @@ export async function refreshAccessToken(clientId, clientSecret, refreshToken) {
 }
 
 /**
- * Get a valid access token — refreshes automatically if expired.
+ * Get a valid Google access token — refreshes automatically if expired.
  * @param {object} config — NHA config with google.clientId etc.
  * @returns {Promise<string>} access_token
  */
 export async function getAccessToken(config) {
-  let tokens = loadTokens();
+  let tokens = loadTokens('google');
   if (!tokens) throw new Error('Not authenticated. Run: nha google auth');
 
   if (isExpired(tokens)) {
@@ -137,9 +153,20 @@ export async function getAccessToken(config) {
     if (!clientId) throw new Error('Google client ID not configured');
 
     tokens = await refreshAccessToken(clientId, clientSecret, tokens.refresh_token);
-    tokens.email = loadTokens()?.email; // preserve email
-    saveTokens(tokens);
+    tokens.email = loadTokens('google')?.email; // preserve email
+    saveTokens(tokens, 'google');
   }
 
   return tokens.access_token;
 }
+
+/**
+ * Check which providers are currently authenticated.
+ * @returns {{ google: boolean, microsoft: boolean }}
+ */
+export function getAuthenticatedProviders() {
+  return {
+    google: loadTokens('google') !== null,
+    microsoft: loadTokens('microsoft') !== null,
+  };
+}

package/src/services/tool-executor.mjs

@@ -0,0 +1,392 @@
+/**
+ * Shared tool executor and action parser — used by chat.mjs, ui.mjs, and voice.mjs.
+ *
+ * Centralizes the JSON action block parsing and tool execution logic
+ * to eliminate code duplication across the three PAO interfaces.
+ *
+ * Zero dependencies — pure Node.js 22.
+ */
+
+import {
+  listMessages,
+  getMessage,
+  getUnreadImportant,
+  sendEmail,
+  createDraft,
+  getTodayEvents,
+  getUpcomingEvents,
+  getEventsForDate,
+  createEvent,
+  updateEvent,
+} from './mail-router.mjs';
+
+import {
+  getTasks,
+  addTask,
+  completeTask,
+  moveTask,
+} from './task-store.mjs';
+
+import { notify } from './notification.mjs';
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+/** Actions that mutate external state and require user confirmation. */
+export const DESTRUCTIVE_ACTIONS = new Set([
+  'gmail_send',
+  'gmail_reply',
+  'calendar_create',
+  'calendar_move',
+  'task_done',
+  'notify_remind',
+]);
+
+// ── System Prompt (tool definitions) ─────────────────────────────────────────
+
+/**
+ * Build the tool definitions system prompt block.
+ * Callers should replace {{TODAY}} and {{TIMEZONE}} and append their own persona.
+ */
+export const TOOL_DEFINITIONS = `
+You have access to the following tools. When the user's message requires an action,
+output EXACTLY ONE fenced JSON block per action:
+
+\`\`\`json
+{"action": "<tool_name>", "params": { ... }}
+\`\`\`
+
+You may include conversational text BEFORE or AFTER the JSON block. If no action
+is needed, respond normally without any JSON block.
+
+TOOLS:
+
+1. gmail_list(query: string, maxResults?: number)
+   Search emails. query uses Gmail search syntax (e.g. "from:boss@co.com", "is:unread subject:invoice").
+   Default maxResults = 10.
+
+2. gmail_read(messageId: string)
+   Read the full body of an email by its ID (returned by gmail_list).
+
+3. gmail_send(to: string, subject: string, body: string)
+   Send an email. ALWAYS confirm with the user before sending.
+
+4. gmail_draft(to: string, subject: string, body: string)
+   Create a draft email (safe — does not send).
+
+5. gmail_reply(messageId: string, body: string)
+   Reply to an existing email thread. ALWAYS confirm before sending.
+
+6. calendar_today()
+   List all events for today.
+
+7. calendar_tomorrow()
+   List all events for tomorrow.
+
+8. calendar_upcoming(hours?: number)
+   List upcoming events in the next N hours (default 2).
+
+9. calendar_create(summary: string, start: string, end: string, attendees?: string[], description?: string)
+   Create a calendar event. start/end are ISO 8601 datetime strings.
+   ALWAYS confirm with the user before creating.
+
+10. calendar_move(eventId: string, newStart: string, newEnd: string)
+    Reschedule an event. ALWAYS confirm before moving.
+
+11. task_list()
+    List today's tasks.
+
+12. task_add(description: string, priority?: "low"|"medium"|"high"|"critical", due?: string)
+    Add a new task for today.
+
+13. task_done(id: number)
+    Mark a task as completed. Confirm before completing.
+
+14. task_move(id: number, toDate: string)
+    Move a task to another date (YYYY-MM-DD).
+
+15. notify_remind(message: string, atTime: string)
+    Set a desktop reminder. atTime is ISO 8601 or relative like "in 30 minutes".
+
+RULES:
+- For search/read operations, execute immediately and present results conversationally.
+- For write/send/delete operations (gmail_send, gmail_reply, calendar_create, calendar_move, task_done, notify_remind), DESCRIBE what you're about to do and include the JSON block so the system can ask the user for confirmation.
+- When presenting email results, show From, Subject, Date, and a brief snippet. Never dump raw JSON.
+- When presenting calendar events, show Time, Title, Location/Link. Format times in a human-readable way.
+- When presenting tasks, show ID, Description, Priority, Status.
+- If you need multiple actions in sequence (e.g., read an email then reply), do them ONE AT A TIME — wait for the result of each before proceeding.
+- Dates: today is {{TODAY}}. Infer relative dates from this.
+- The user's timezone is {{TIMEZONE}}.
+- CRITICAL: when creating calendar events, always use LOCAL time in format "YYYY-MM-DDTHH:MM:SS" WITHOUT any Z suffix or timezone offset.
+`.trim();
+
+// ── Action Parser ────────────────────────────────────────────────────────────
+
+/**
+ * Extract JSON action blocks from LLM response text.
+ * Supports ```json ... ``` fenced blocks.
+ *
+ * @param {string} text
+ * @returns {{ textParts: string[], actions: Array<{action: string, params: object}> }}
+ */
+export function parseActions(text) {
+  const actions = [];
+  const textParts = [];
+  const fenceRegex = /```json\s*\n?([\s\S]*?)```/g;
+  let lastIndex = 0;
+  let match;
+
+  while ((match = fenceRegex.exec(text)) !== null) {
+    const before = text.slice(lastIndex, match.index).trim();
+    if (before) textParts.push(before);
+
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      if (parsed.action && typeof parsed.action === 'string') {
+        actions.push({ action: parsed.action, params: parsed.params || {} });
+      }
+    } catch {
+      textParts.push(match[0]);
+    }
+
+    lastIndex = match.index + match[0].length;
+  }
+
+  const trailing = text.slice(lastIndex).trim();
+  if (trailing) textParts.push(trailing);
+
+  return { textParts, actions };
+}
+
+// ── Formatting Helpers ───────────────────────────────────────────────────────
+
+/**
+ * Format an ISO timestamp into a human-readable time string.
+ */
+export function formatTime(isoStr) {
+  try {
+    const d = new Date(isoStr);
+    return d.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: true });
+  } catch {
+    return isoStr;
+  }
+}
+
+/**
+ * Format an array of calendar events into human-readable text.
+ */
+export function formatEvents(events) {
+  return events.map((e, i) => {
+    const time = e.isAllDay ? 'All day' : `${formatTime(e.start)} - ${formatTime(e.end)}`;
+    const location = e.location ? ` | ${e.location}` : '';
+    const link = e.hangoutLink ? ` | ${e.hangoutLink}` : '';
+    const cal = e.calendarName ? ` (${e.calendarName})` : '';
+    return `${i + 1}. ${time} — ${e.summary}${location}${link}${cal}`;
+  }).join('\n');
+}
+
+/**
+ * Resolve a time string into a Date. Supports ISO 8601 and relative formats
+ * like "in 30 minutes", "in 2 hours".
+ */
+export function resolveTime(timeStr) {
+  const direct = new Date(timeStr);
+  if (!isNaN(direct.getTime()) && timeStr.includes('T')) return direct;
+
+  const relMatch = timeStr.match(/in\s+(\d+)\s+(minute|min|hour|hr)s?/i);
+  if (relMatch) {
+    const amount = parseInt(relMatch[1], 10);
+    const unit = relMatch[2].toLowerCase();
+    const ms = unit.startsWith('h') ? amount * 3600000 : amount * 60000;
+    return new Date(Date.now() + ms);
+  }
+
+  const today = new Date();
+  const timeOnly = new Date(`${today.toISOString().split('T')[0]}T${timeStr}`);
+  if (!isNaN(timeOnly.getTime())) return timeOnly;
+
+  return new Date(Date.now() + 1800000);
+}
+
+/**
+ * Build a human-readable description of an action (for confirmation prompts).
+ */
+export function describeAction(action, params) {
+  switch (action) {
+    case 'gmail_send':
+      return `Send email to ${params.to} — Subject: "${params.subject}"`;
+    case 'gmail_reply':
+      return `Reply to message ${params.messageId}`;
+    case 'calendar_create':
+      return `Create event "${params.summary}" at ${formatTime(params.start)}`;
+    case 'calendar_move':
+      return `Reschedule event ${params.eventId} to ${formatTime(params.newStart)}`;
+    case 'task_done':
+      return `Mark task #${params.id} as completed`;
+    case 'notify_remind':
+      return `Set reminder: "${params.message}" at ${params.atTime}`;
+    default:
+      return `Execute ${action}`;
+  }
+}
+
+// ── Tool Executor ────────────────────────────────────────────────────────────
+
+/**
+ * Execute a parsed tool action and return a human-readable result string.
+ *
+ * @param {string} action — tool name
+ * @param {object} params — tool parameters
+ * @param {object} config — NHA config
+ * @returns {Promise<string>} result description
+ */
+export async function executeTool(action, params, config) {
+  switch (action) {
+    // ── Gmail ──────────────────────────────────────────────────────────────
+    case 'gmail_list': {
+      const query = params.query || 'is:unread';
+      const max = params.maxResults || 10;
+      const refs = await listMessages(config, query, max);
+      if (refs.length === 0) return 'No emails found matching that query.';
+
+      const messages = [];
+      for (const ref of refs.slice(0, max)) {
+        try {
+          const msg = await getMessage(config, ref.id);
+          messages.push(msg);
+        } catch { /* skip failed */ }
+      }
+
+      return messages.map((m, i) =>
+        `${i + 1}. [${m.id}] From: ${m.from} | Subject: ${m.subject} | Date: ${m.date}\n   ${m.snippet.slice(0, 120)}`
+      ).join('\n');
+    }
+
+    case 'gmail_read': {
+      const msg = await getMessage(config, params.messageId);
+      return [
+        `From: ${msg.from}`,
+        `To: ${msg.to}`,
+        `Subject: ${msg.subject}`,
+        `Date: ${msg.date}`,
+        `---`,
+        msg.body.slice(0, 4000),
+      ].join('\n');
+    }
+
+    case 'gmail_send': {
+      await sendEmail(config, params.to, params.subject, params.body);
+      return `Email sent to ${params.to} with subject "${params.subject}".`;
+    }
+
+    case 'gmail_draft': {
+      await createDraft(config, params.to, params.subject, params.body);
+      return `Draft created for ${params.to} with subject "${params.subject}".`;
+    }
+
+    case 'gmail_reply': {
+      const original = await getMessage(config, params.messageId);
+      await sendEmail(config, original.from, `Re: ${original.subject}`, params.body, {
+        replyToMessageId: original.id,
+        threadId: original.threadId,
+      });
+      return `Reply sent to ${original.from} on thread "${original.subject}".`;
+    }
+
+    // ── Calendar ──────────────────────────────────────────────────────────
+    case 'calendar_today': {
+      const events = await getTodayEvents(config);
+      if (events.length === 0) return 'No events scheduled for today.';
+      return formatEvents(events);
+    }
+
+    case 'calendar_tomorrow': {
+      const tomorrow = new Date();
+      tomorrow.setDate(tomorrow.getDate() + 1);
+      const dateStr = tomorrow.toISOString().split('T')[0];
+      const events = await getEventsForDate(config, dateStr);
+      if (events.length === 0) return 'No events scheduled for tomorrow.';
+      return formatEvents(events);
+    }
+
+    case 'calendar_upcoming': {
+      const hours = params.hours || 2;
+      const events = await getUpcomingEvents(config, hours);
+      if (events.length === 0) return `No events in the next ${hours} hour(s).`;
+      return formatEvents(events);
+    }
+
+    case 'calendar_create': {
+      await createEvent(config, {
+        summary: params.summary,
+        start: params.start,
+        end: params.end,
+        description: params.description || '',
+        attendees: params.attendees || [],
+      });
+      return `Event "${params.summary}" created for ${formatTime(params.start)} - ${formatTime(params.end)}.`;
+    }
+
+    case 'calendar_move': {
+      const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      await updateEvent(config, 'primary', params.eventId, {
+        start: { dateTime: new Date(params.newStart).toISOString(), timeZone: tz },
+        end: { dateTime: new Date(params.newEnd).toISOString(), timeZone: tz },
+      });
+      return `Event rescheduled to ${formatTime(params.newStart)} - ${formatTime(params.newEnd)}.`;
+    }
+
+    // ── Tasks ─────────────────────────────────────────────────────────────
+    case 'task_list': {
+      const tasks = getTasks();
+      if (tasks.length === 0) return 'No tasks for today.';
+      return tasks.map(t =>
+        `#${t.id} [${t.priority}] ${t.status === 'done' ? '[DONE] ' : ''}${t.description}${t.due ? ' (due: ' + t.due + ')' : ''}`
+      ).join('\n');
+    }
+
+    case 'task_add': {
+      const task = addTask({
+        description: params.description,
+        priority: params.priority || 'medium',
+        due: params.due || null,
+        source: 'tool',
+      });
+      return `Task #${task.id} added: "${task.description}" [${task.priority}]`;
+    }
+
+    case 'task_done': {
+      const success = completeTask(params.id);
+      return success ? `Task #${params.id} marked as done.` : `Task #${params.id} not found.`;
+    }
+
+    case 'task_move': {
+      const todayStr = new Date().toISOString().split('T')[0];
+      const toDate = params.toDate === 'tomorrow'
+        ? new Date(new Date().setDate(new Date().getDate() + 1)).toISOString().split('T')[0]
+        : params.toDate;
+      const success = moveTask(params.id, todayStr, toDate);
+      return success ? `Task #${params.id} moved to ${toDate}.` : `Task #${params.id} not found.`;
+    }
+
+    // ── Notifications ─────────────────────────────────────────────────────
+    case 'notify_remind': {
+      const atTime = resolveTime(params.atTime);
+      const delayMs = atTime.getTime() - Date.now();
+
+      if (delayMs <= 0) {
+        await notify('Reminder', params.message, config);
+        return `Reminder sent now: "${params.message}"`;
+      }
+
+      setTimeout(async () => {
+        try { await notify('Reminder', params.message, config); } catch { /* best effort */ }
+      }, Math.min(delayMs, 86400000));
+
+      const minutes = Math.round(delayMs / 60000);
+      return `Reminder set for ${formatTime(atTime.toISOString())} (in ~${minutes} min): "${params.message}"`;
+    }
+
+    default:
+      return `Unknown action: ${action}`;
+  }
+}