@conversionpros/aiva 1.0.0

package/gateway-monitor.js

@@ -0,0 +1,158 @@
+/**
+ * AIVA Gateway Health Monitor
+ * Checks gateway health every 60s with 3-tier recovery escalation.
+ * Alerts Brandon via AIVA chat API (primary) and iMessage (fallback).
+ * Cooldown: max 1 recovery attempt per 5 minutes.
+ */
+
+const http = require('http');
+const { exec, execSync } = require('child_process');
+
+const GATEWAY_URL = 'http://localhost:18789';
+const AIVA_CHAT_URL = 'http://localhost:3847/api/chat/aiva-reply';
+const BRANDON_PHONE = '+15099794110';
+const CHECK_INTERVAL_MS = 60 * 1000;
+const COOLDOWN_MS = 5 * 60 * 1000;
+const RECHECK_DELAY_MS = 15 * 1000;
+
+let lastRecoveryAttempt = 0;
+
+function log(msg) {
+  console.log(`[gateway-monitor] ${new Date().toISOString()} ${msg}`);
+}
+
+function probeGateway() {
+  return new Promise((resolve) => {
+    const req = http.get(GATEWAY_URL, { timeout: 5000 }, (res) => {
+      res.resume();
+      resolve(true);
+    });
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => { req.destroy(); resolve(false); });
+  });
+}
+
+function runCommand(cmd) {
+  return new Promise((resolve) => {
+    exec(cmd, { timeout: 30000 }, (err, stdout, stderr) => {
+      resolve({ err, stdout, stderr });
+    });
+  });
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Send alert to Brandon via AIVA chat API (primary) with iMessage fallback.
+ */
+async function alertBrandon(message) {
+  const timestamp = new Date().toLocaleString('en-US', { timeZone: 'America/Los_Angeles' });
+  const fullMessage = `${message}\n🕐 ${timestamp}`;
+
+  // Primary: AIVA chat API
+  let aivaSent = false;
+  try {
+    aivaSent = await new Promise((resolve) => {
+      const postData = JSON.stringify({ userId: 'brandon', text: fullMessage });
+      const req = http.request(AIVA_CHAT_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'x-aiva-internal': 'true' },
+        timeout: 5000,
+      }, (res) => {
+        res.resume();
+        resolve(res.statusCode >= 200 && res.statusCode < 300);
+      });
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => { req.destroy(); resolve(false); });
+      req.write(postData);
+      req.end();
+    });
+    if (aivaSent) {
+      log(`Alert sent via AIVA chat: ${message}`);
+    }
+  } catch (e) {
+    log(`AIVA chat alert failed: ${e.message}`);
+  }
+
+  // Fallback: iMessage via imsg CLI if AIVA failed
+  if (!aivaSent) {
+    try {
+      execSync(`/opt/homebrew/bin/imsg send "${BRANDON_PHONE}" "${fullMessage.replace(/"/g, '\\"')}"`, { timeout: 10000 });
+      log(`Alert sent via iMessage fallback: ${message}`);
+    } catch (e) {
+      log(`CRITICAL: Both AIVA and iMessage alerts failed! Message was: ${message}`);
+    }
+  }
+}
+
+async function recover() {
+  const now = Date.now();
+  if (now - lastRecoveryAttempt < COOLDOWN_MS) {
+    log('Cooldown active — skipping recovery');
+    return;
+  }
+  lastRecoveryAttempt = now;
+
+  await alertBrandon('🚨 AIVA Gateway DOWN — starting automatic recovery...');
+
+  // Tier 1: Simple restart
+  log('TIER 1: Gateway unreachable — running openclaw gateway start');
+  await runCommand('/opt/homebrew/bin/openclaw gateway start');
+  await sleep(RECHECK_DELAY_MS);
+  if (await probeGateway()) {
+    log('TIER 1: Recovery successful — gateway is healthy');
+    await alertBrandon('✅ AIVA Gateway RECOVERED via simple restart (Tier 1)');
+    return;
+  }
+
+  // Tier 2: Doctor repair
+  log('TIER 2: Still unreachable — running openclaw doctor --repair');
+  await alertBrandon('⚠️ Simple restart failed. Trying doctor --repair (Tier 2)...');
+  await runCommand('/opt/homebrew/bin/openclaw doctor --repair');
+  await runCommand('/opt/homebrew/bin/openclaw gateway start');
+  await sleep(RECHECK_DELAY_MS);
+  if (await probeGateway()) {
+    log('TIER 2: Recovery successful — gateway is healthy');
+    await alertBrandon('✅ AIVA Gateway RECOVERED via doctor --repair (Tier 2)');
+    return;
+  }
+
+  // Tier 3: Claude Code escalation
+  log('TIER 3: Escalating to Claude Code for diagnosis');
+  await alertBrandon('🔴 GATEWAY STILL DOWN after Tier 1 & 2. Escalating to Claude Code (Tier 3)...');
+  const claudeCmd = `claude -p "The AIVA gateway on this machine failed to start. Run 'openclaw gateway start' and 'openclaw doctor --repair' to diagnose. Check logs at ~/.openclaw/logs/. Fix whatever is wrong and get the gateway running." --allowedTools bash,computer`;
+  exec(claudeCmd, { timeout: 300000 }, async (err, stdout, stderr) => {
+    // Check if gateway came back after Claude Code
+    await sleep(30000);
+    if (await probeGateway()) {
+      await alertBrandon('✅ AIVA Gateway RECOVERED via Claude Code escalation (Tier 3)');
+    } else {
+      await alertBrandon('🚨🚨 CRITICAL: AIVA Gateway STILL DOWN after all recovery tiers. NEEDS MANUAL INTERVENTION! 🚨🚨');
+    }
+  });
+}
+
+async function check() {
+  try {
+    const healthy = await probeGateway();
+    if (!healthy) {
+      log('Gateway health check FAILED — starting recovery');
+      await recover();
+    }
+  } catch (err) {
+    log(`Monitor error (continuing): ${err.message}`);
+  }
+}
+
+function start() {
+  log('Started — checking gateway every 60s');
+  // Initial check after 10s (let app finish starting)
+  setTimeout(() => {
+    check();
+    setInterval(check, CHECK_INTERVAL_MS);
+  }, 10000);
+}
+
+module.exports = { start };

package/google-email.js

@@ -0,0 +1,379 @@
+/**
+ * Google Email (Gmail) API Endpoints - Phase 2
+ * 
+ * Endpoints:
+ *   GET    /api/integrations/google/emails          - List emails
+ *   GET    /api/integrations/google/emails/:id       - Get single email
+ *   POST   /api/integrations/google/emails/send      - Send email
+ *   POST   /api/integrations/google/emails/:id/reply - Reply to email
+ *   DELETE  /api/integrations/google/emails/:id       - Trash email
+ *   POST   /api/integrations/google/emails/:id/labels - Modify labels
+ */
+
+const express = require('express');
+const router = express.Router();
+const { getValidAccessToken, loadTokens } = require('./google-oauth');
+
+const GMAIL_BASE = 'https://gmail.googleapis.com/gmail/v1/users/me';
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function resolveAccountId(query, body) {
+  const accountId = (body && body.accountId) || (query && query.accountId);
+  if (accountId) return accountId;
+  // If no accountId, try to use first account
+  const store = loadTokens();
+  if (store.google.accounts.length === 1) return store.google.accounts[0].id;
+  return null;
+}
+
+async function gmailFetch(token, endpoint, options = {}) {
+  const url = endpoint.startsWith('http') ? endpoint : `${GMAIL_BASE}${endpoint}`;
+  const resp = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      ...(options.headers || {}),
+    },
+  });
+  if (!resp.ok) {
+    const errText = await resp.text();
+    const err = new Error(`Gmail API error ${resp.status}`);
+    err.status = resp.status;
+    err.details = errText;
+    throw err;
+  }
+  return resp.json();
+}
+
+function parseEmailHeaders(headers) {
+  const get = (name) => {
+    const h = headers.find(h => h.name.toLowerCase() === name.toLowerCase());
+    return h ? h.value : null;
+  };
+  return { from: get('From'), to: get('To'), cc: get('Cc'), bcc: get('Bcc'), subject: get('Subject'), date: get('Date'), messageId: get('Message-ID'), inReplyTo: get('In-Reply-To'), references: get('References') };
+}
+
+function extractBody(payload) {
+  if (!payload) return { text: null, html: null };
+  
+  // Simple single-part message
+  if (payload.body && payload.body.size > 0 && payload.body.data) {
+    const decoded = Buffer.from(payload.body.data, 'base64url').toString('utf8');
+    if (payload.mimeType === 'text/html') return { text: null, html: decoded };
+    return { text: decoded, html: null };
+  }
+
+  // Multipart
+  let text = null, html = null;
+  function walk(parts) {
+    if (!parts) return;
+    for (const part of parts) {
+      if (part.mimeType === 'text/plain' && part.body && part.body.data) {
+        text = Buffer.from(part.body.data, 'base64url').toString('utf8');
+      } else if (part.mimeType === 'text/html' && part.body && part.body.data) {
+        html = Buffer.from(part.body.data, 'base64url').toString('utf8');
+      } else if (part.parts) {
+        walk(part.parts);
+      }
+    }
+  }
+  walk(payload.parts);
+  return { text, html };
+}
+
+function extractAttachments(payload) {
+  const attachments = [];
+  function walk(parts) {
+    if (!parts) return;
+    for (const part of parts) {
+      if (part.filename && part.filename.length > 0) {
+        attachments.push({
+          partId: part.partId,
+          filename: part.filename,
+          mimeType: part.mimeType,
+          size: part.body ? part.body.size : 0,
+          attachmentId: part.body ? part.body.attachmentId : null,
+        });
+      }
+      if (part.parts) walk(part.parts);
+    }
+  }
+  walk(payload.parts);
+  return attachments;
+}
+
+function buildRawEmail({ from, to, cc, bcc, subject, body, inReplyTo, references, threadId }) {
+  const lines = [];
+  lines.push(`From: ${from}`);
+  lines.push(`To: ${Array.isArray(to) ? to.join(', ') : to}`);
+  if (cc) lines.push(`Cc: ${Array.isArray(cc) ? cc.join(', ') : cc}`);
+  if (bcc) lines.push(`Bcc: ${Array.isArray(bcc) ? bcc.join(', ') : bcc}`);
+  lines.push(`Subject: ${subject}`);
+  if (inReplyTo) lines.push(`In-Reply-To: ${inReplyTo}`);
+  if (references) lines.push(`References: ${references}`);
+  lines.push('MIME-Version: 1.0');
+  lines.push('Content-Type: text/html; charset=UTF-8');
+  lines.push('');
+  lines.push(body);
+
+  const raw = Buffer.from(lines.join('\r\n')).toString('base64url');
+  return raw;
+}
+
+function wrapResponse(data) {
+  return { success: true, data, error: null };
+}
+
+function wrapError(message, extra = {}) {
+  return { success: false, data: null, error: message, ...extra };
+}
+
+// ─── Middleware to resolve account ─────────────────────────────────────────────
+
+async function withAccount(req, res, next) {
+  const accountId = resolveAccountId(req.query, req.body);
+  if (!accountId) {
+    return res.status(400).json(wrapError('accountId is required (query or body param). Multiple accounts linked.'));
+  }
+  try {
+    const { token, email } = await getValidAccessToken(accountId);
+    req.gmailToken = token;
+    req.gmailEmail = email;
+    req.gmailAccountId = accountId;
+    next();
+  } catch (e) {
+    if (e.message === 'GOOGLE_AUTH_EXPIRED') {
+      return res.status(401).json(wrapError('GOOGLE_AUTH_EXPIRED', { message: 'Google account requires re-authentication', accountId }));
+    }
+    if (e.message === 'Account not found') {
+      return res.status(404).json(wrapError('Account not found', { accountId }));
+    }
+    console.error('[google-email] Auth error:', e.message);
+    return res.status(500).json(wrapError(e.message));
+  }
+}
+
+// ─── Routes ───────────────────────────────────────────────────────────────────
+
+// 1. List emails
+router.get('/', withAccount, async (req, res) => {
+  try {
+    const { maxResults = '20', pageToken, q, labelIds } = req.query;
+    const params = new URLSearchParams({ maxResults });
+    if (pageToken) params.set('pageToken', pageToken);
+    if (q) params.set('q', q);
+    if (labelIds) {
+      const labels = Array.isArray(labelIds) ? labelIds : labelIds.split(',');
+      labels.forEach(l => params.append('labelIds', l.trim()));
+    } else {
+      params.append('labelIds', 'INBOX');
+    }
+
+    const listData = await gmailFetch(req.gmailToken, `/messages?${params}`);
+    
+    if (!listData.messages || listData.messages.length === 0) {
+      return res.json(wrapResponse({ messages: [], nextPageToken: null, resultSizeEstimate: 0 }));
+    }
+
+    // Batch fetch metadata for each message
+    const messages = await Promise.all(
+      listData.messages.map(async (m) => {
+        const msg = await gmailFetch(req.gmailToken, `/messages/${m.id}?format=metadata&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Subject&metadataHeaders=Date`);
+        const headers = parseEmailHeaders(msg.payload ? msg.payload.headers : []);
+        return {
+          id: msg.id,
+          threadId: msg.threadId,
+          snippet: msg.snippet,
+          labelIds: msg.labelIds,
+          isUnread: (msg.labelIds || []).includes('UNREAD'),
+          from: headers.from,
+          to: headers.to,
+          subject: headers.subject,
+          date: headers.date,
+          internalDate: msg.internalDate,
+        };
+      })
+    );
+
+    res.json(wrapResponse({
+      messages,
+      nextPageToken: listData.nextPageToken || null,
+      resultSizeEstimate: listData.resultSizeEstimate || messages.length,
+    }));
+  } catch (e) {
+    console.error('[google-email] List error:', e.message);
+    res.status(e.status || 500).json(wrapError(e.message, { details: e.details }));
+  }
+});
+
+// 2. Draft operations (MUST be before /:id to avoid route conflict)
+router.post('/drafts', withAccount, async (req, res) => {
+  try {
+    const { to, cc, bcc, subject, body, from } = req.body;
+    if (!to || !subject || !body) {
+      return res.status(400).json(wrapError('to, subject, and body are required'));
+    }
+
+    const raw = buildRawEmail({ from: from || req.gmailEmail, to, cc, bcc, subject, body });
+    const result = await gmailFetch(req.gmailToken, '/drafts', {
+      method: 'POST',
+      body: JSON.stringify({ message: { raw } }),
+    });
+
+    res.json(wrapResponse({ draftId: result.id, messageId: result.message?.id, threadId: result.message?.threadId }));
+  } catch (e) {
+    console.error('[google-email] Draft create error:', e.message);
+    res.status(e.status || 500).json(wrapError(e.message, { details: e.details }));
+  }
+});
+
+router.get('/drafts', withAccount, async (req, res) => {
+  try {
+    const maxResults = req.query.maxResults || 10;
+    const result = await gmailFetch(req.gmailToken, `/drafts?maxResults=${maxResults}`);
+    res.json(wrapResponse(result.drafts || []));
+  } catch (e) {
+    console.error('[google-email] Draft list error:', e.message);
+    res.status(e.status || 500).json(wrapError(e.message));
+  }
+});
+
+router.delete('/drafts/:draftId', withAccount, async (req, res) => {
+  try {
+    const resp = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/drafts/${req.params.draftId}`, {
+      method: 'DELETE',
+      headers: { 'Authorization': `Bearer ${req.gmailToken}` },
+    });
+    if (!resp.ok && resp.status !== 204) {
+      const errText = await resp.text().catch(() => '');
+      throw new Error(`Gmail API error ${resp.status}: ${errText}`);
+    }
+    res.json(wrapResponse({ deleted: true, draftId: req.params.draftId }));
+  } catch (e) {
+    console.error('[google-email] Draft delete error:', e.message);
+    res.status(e.status || 500).json(wrapError(e.message));
+  }
+});
+
+// 3. Get single email
+router.get('/:id', withAccount, async (req, res) => {
+  try {
+    const msg = await gmailFetch(req.gmailToken, `/messages/${req.params.id}?format=full`);
+    const headers = parseEmailHeaders(msg.payload ? msg.payload.headers : []);
+    const body = extractBody(msg.payload);
+    const attachments = extractAttachments(msg.payload);
+
+    res.json(wrapResponse({
+      id: msg.id,
+      threadId: msg.threadId,
+      snippet: msg.snippet,
+      labelIds: msg.labelIds,
+      isUnread: (msg.labelIds || []).includes('UNREAD'),
+      headers,
+      body,
+      attachments,
+      sizeEstimate: msg.sizeEstimate,
+      internalDate: msg.internalDate,
+    }));
+  } catch (e) {
+    console.error('[google-email] Get error:', e.message);
+    res.status(e.status || 500).json(wrapError(e.message, { details: e.details }));
+  }
+});
+
+// 3. Send email
+router.post('/send', withAccount, async (req, res) => {
+  try {
+    const { to, cc, bcc, subject, body, threadId } = req.body;
+    if (!to || !subject || !body) {
+      return res.status(400).json(wrapError('to, subject, and body are required'));
+    }
+
+    const raw = buildRawEmail({ from: req.gmailEmail, to, cc, bcc, subject, body });
+    const payload = { raw };
+    if (threadId) payload.threadId = threadId;
+
+    const result = await gmailFetch(req.gmailToken, '/messages/send', {
+      method: 'POST',
+      body: JSON.stringify(payload),
+    });
+
+    res.json(wrapResponse({ id: result.id, threadId: result.threadId, labelIds: result.labelIds }));
+  } catch (e) {
+    console.error('[google-email] Send error:', e.message);
+    res.status(e.status || 500).json(wrapError(e.message, { details: e.details }));
+  }
+});
+
+// 5. Reply to email
+router.post('/:id/reply', withAccount, async (req, res) => {
+  try {
+    const { body } = req.body;
+    if (!body) return res.status(400).json(wrapError('body is required'));
+
+    // Fetch original message for threading info
+    const original = await gmailFetch(req.gmailToken, `/messages/${req.params.id}?format=metadata&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Subject&metadataHeaders=Message-ID&metadataHeaders=References`);
+    const origHeaders = parseEmailHeaders(original.payload ? original.payload.headers : []);
+
+    const replyTo = origHeaders.from;
+    const subject = origHeaders.subject && origHeaders.subject.startsWith('Re:') ? origHeaders.subject : `Re: ${origHeaders.subject || ''}`;
+    const references = [origHeaders.references, origHeaders.messageId].filter(Boolean).join(' ');
+
+    const raw = buildRawEmail({
+      from: req.gmailEmail,
+      to: replyTo,
+      subject,
+      body,
+      inReplyTo: origHeaders.messageId,
+      references,
+    });
+
+    const result = await gmailFetch(req.gmailToken, '/messages/send', {
+      method: 'POST',
+      body: JSON.stringify({ raw, threadId: original.threadId }),
+    });
+
+    res.json(wrapResponse({ id: result.id, threadId: result.threadId, labelIds: result.labelIds }));
+  } catch (e) {
+    console.error('[google-email] Reply error:', e.message);
+    res.status(e.status || 500).json(wrapError(e.message, { details: e.details }));
+  }
+});
+
+// 5. Trash email
+router.delete('/:id', withAccount, async (req, res) => {
+  try {
+    await gmailFetch(req.gmailToken, `/messages/${req.params.id}/trash`, { method: 'POST' });
+    res.json(wrapResponse({ id: req.params.id, trashed: true }));
+  } catch (e) {
+    console.error('[google-email] Trash error:', e.message);
+    res.status(e.status || 500).json(wrapError(e.message, { details: e.details }));
+  }
+});
+
+// 6. Modify labels (read/unread, archive, etc.)
+router.post('/:id/labels', withAccount, async (req, res) => {
+  try {
+    const { addLabelIds, removeLabelIds } = req.body;
+    if (!addLabelIds && !removeLabelIds) {
+      return res.status(400).json(wrapError('addLabelIds or removeLabelIds required'));
+    }
+
+    const result = await gmailFetch(req.gmailToken, `/messages/${req.params.id}/modify`, {
+      method: 'POST',
+      body: JSON.stringify({
+        addLabelIds: addLabelIds || [],
+        removeLabelIds: removeLabelIds || [],
+      }),
+    });
+
+    res.json(wrapResponse({ id: result.id, threadId: result.threadId, labelIds: result.labelIds }));
+  } catch (e) {
+    console.error('[google-email] Labels error:', e.message);
+    res.status(e.status || 500).json(wrapError(e.message, { details: e.details }));
+  }
+});
+
+module.exports = { router };