@cli4ai/gmail 1.0.1 → 1.0.3

package/lib/api.ts

@@ -0,0 +1,299 @@
+import fs from 'fs';
+import path from 'path';
+import { google, gmail_v1 } from 'googleapis';
+import readline from 'readline';
+import type { OAuth2Client } from 'google-auth-library';
+
+// Load env from root .env
+const SCRIPT_DIR = path.dirname(import.meta.dir);
+const ENV_FILE = path.join(SCRIPT_DIR, '../.env');
+if (fs.existsSync(ENV_FILE)) {
+  const envContent = fs.readFileSync(ENV_FILE, 'utf-8');
+  envContent.split('\n').forEach(line => {
+    const [key, ...vals] = line.split('=');
+    if (key && !key.startsWith('#')) {
+      process.env[key.trim()] = vals.join('=').trim();
+    }
+  });
+}
+
+// Paths for credentials and token
+const CREDENTIALS_PATH = process.env.GMAIL_CREDENTIALS_PATH || path.join(SCRIPT_DIR, 'credentials.json');
+const TOKEN_PATH = process.env.GMAIL_TOKEN_PATH || path.join(SCRIPT_DIR, 'token.json');
+
+// Scopes for Gmail access
+const SCOPES = [
+  'https://www.googleapis.com/auth/gmail.modify',
+  'https://www.googleapis.com/auth/gmail.compose',
+  'https://www.googleapis.com/auth/gmail.send'
+];
+
+let gmailClient: gmail_v1.Gmail | null = null;
+let authClient: OAuth2Client | null = null;
+
+/** Output options */
+export interface OutputOptions {
+  raw?: boolean;
+  compact?: boolean;
+  body?: boolean;
+  fullBody?: boolean;
+  attach?: string | string[];
+  cc?: string;
+  bcc?: string;
+  limit?: number;
+  query?: string;
+}
+
+/** Message output data for compact display */
+export interface MessageOutputData {
+  date?: string | null;
+  from?: string;
+  subject?: string;
+}
+
+/** Email headers */
+export interface EmailHeaders {
+  from?: string;
+  to?: string;
+  cc?: string;
+  bcc?: string;
+  subject?: string;
+  date?: string;
+  reply_to?: string;
+  message_id?: string;
+  references?: string;
+}
+
+/** Message payload */
+export interface MessagePayload {
+  headers?: Array<{ name: string; value: string }>;
+  body?: { data?: string; size?: number; attachmentId?: string };
+  parts?: MessagePayload[];
+  mimeType?: string;
+  filename?: string;
+  partId?: string;
+}
+
+/**
+ * Get new token via OAuth flow
+ */
+async function getNewToken(oAuth2Client: OAuth2Client): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const authUrl = oAuth2Client.generateAuthUrl({
+      access_type: 'offline',
+      scope: SCOPES,
+    });
+    console.error('Authorize this app by visiting this url:');
+    console.error(authUrl);
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stderr,
+    });
+
+    rl.question('Enter the code from that page here: ', (code: string) => {
+      rl.close();
+      oAuth2Client.getToken(code, (err, token) => {
+        if (err) {
+          reject(new Error(`Error retrieving access token: ${err.message}`));
+          return;
+        }
+        oAuth2Client.setCredentials(token!);
+        fs.writeFileSync(TOKEN_PATH, JSON.stringify(token));
+        console.error('Token stored to', TOKEN_PATH);
+        resolve();
+      });
+    });
+  });
+}
+
+/**
+ * Authorize and get OAuth2 client
+ */
+export async function authorize(): Promise<OAuth2Client> {
+  if (authClient) return authClient;
+
+  if (!fs.existsSync(CREDENTIALS_PATH)) {
+    throw new Error(`Credentials not found at ${CREDENTIALS_PATH}. Set GMAIL_CREDENTIALS_PATH in .env`);
+  }
+
+  const content = fs.readFileSync(CREDENTIALS_PATH, 'utf-8');
+  const credentials = JSON.parse(content);
+  const { client_secret, client_id, redirect_uris } = credentials.installed || credentials.web;
+
+  const oAuth2Client = new google.auth.OAuth2(
+    client_id,
+    client_secret,
+    redirect_uris[0]
+  );
+
+  // Try to load existing token
+  if (fs.existsSync(TOKEN_PATH)) {
+    const token = JSON.parse(fs.readFileSync(TOKEN_PATH, 'utf-8'));
+    oAuth2Client.setCredentials(token);
+
+    // Set up automatic token refresh
+    oAuth2Client.on('tokens', (tokens) => {
+      const currentToken = JSON.parse(fs.readFileSync(TOKEN_PATH, 'utf-8'));
+      const newToken = { ...currentToken, ...tokens };
+      fs.writeFileSync(TOKEN_PATH, JSON.stringify(newToken));
+    });
+
+    // Try to refresh token if it might be expired
+    try {
+      await oAuth2Client.getAccessToken();
+    } catch (err) {
+      const error = err as Error;
+      if (error.message.includes('invalid_grant') || error.message.includes('Token has been expired')) {
+        console.error('Token expired. Re-authenticating...');
+        fs.unlinkSync(TOKEN_PATH);
+        await getNewToken(oAuth2Client);
+      } else {
+        throw err;
+      }
+    }
+  } else {
+    await getNewToken(oAuth2Client);
+  }
+
+  authClient = oAuth2Client;
+  return oAuth2Client;
+}
+
+/**
+ * Get Gmail API client
+ */
+export async function getGmail(): Promise<gmail_v1.Gmail> {
+  if (gmailClient) return gmailClient;
+
+  const auth = await authorize();
+  gmailClient = google.gmail({ version: 'v1', auth });
+  return gmailClient;
+}
+
+/**
+ * Output data to console
+ */
+export function output(data: unknown, options: OutputOptions = {}): void {
+  if (options.raw) {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (options.compact && Array.isArray(data)) {
+    data.forEach((item: MessageOutputData) => {
+      if (item.date && item.from && item.subject) {
+        const from = item.from.slice(0, 30).padEnd(30);
+        const subject = item.subject.slice(0, 50);
+        console.log(`[${item.date}] ${from} ${subject}`);
+      } else {
+        console.log(JSON.stringify(item));
+      }
+    });
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+
+/**
+ * Format date
+ */
+export function formatDate(timestamp: string | number | undefined | null): string | null {
+  if (!timestamp) return null;
+  const date = new Date(parseInt(String(timestamp)));
+  return date.toISOString().replace('T', ' ').slice(0, 16);
+}
+
+/**
+ * Decode base64url
+ */
+export function decodeBase64Url(str: string | undefined | null): string {
+  if (!str) return '';
+  // Replace URL-safe characters and add padding
+  let normalized = str.replace(/-/g, '+').replace(/_/g, '/');
+  while (normalized.length % 4) normalized += '=';
+  return Buffer.from(normalized, 'base64').toString('utf-8');
+}
+
+/**
+ * Encode to base64url
+ */
+export function encodeBase64Url(str: string): string {
+  return Buffer.from(str)
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '');
+}
+
+/**
+ * Extract headers from message
+ */
+export function extractHeaders(headers: Array<{ name: string; value: string }> | undefined): EmailHeaders {
+  const result: EmailHeaders = {};
+  const headerNames = ['From', 'To', 'Subject', 'Date', 'Cc', 'Bcc', 'Reply-To', 'Message-ID', 'References'];
+
+  for (const header of headers || []) {
+    if (headerNames.includes(header.name)) {
+      const key = header.name.toLowerCase().replace('-', '_') as keyof EmailHeaders;
+      result[key] = header.value;
+    }
+  }
+  return result;
+}
+
+/**
+ * Extract body from message parts
+ */
+export function extractBody(payload: MessagePayload | undefined): string {
+  if (!payload) return '';
+
+  // Simple message with direct body
+  if (payload.body?.data) {
+    return decodeBase64Url(payload.body.data);
+  }
+
+  // Multipart message
+  if (payload.parts) {
+    // Prefer text/plain, fall back to text/html
+    for (const part of payload.parts) {
+      if (part.mimeType === 'text/plain' && part.body?.data) {
+        return decodeBase64Url(part.body.data);
+      }
+    }
+    for (const part of payload.parts) {
+      if (part.mimeType === 'text/html' && part.body?.data) {
+        // Strip HTML tags for plain text
+        const html = decodeBase64Url(part.body.data);
+        return html.replace(/<[^>]*>/g, '').replace(/\s+/g, ' ').trim();
+      }
+    }
+    // Recursively check nested parts
+    for (const part of payload.parts) {
+      if (part.parts) {
+        const body = extractBody(part);
+        if (body) return body;
+      }
+    }
+  }
+
+  return '';
+}
+
+/**
+ * Clean email body for display
+ */
+export function cleanBody(body: string, maxLength?: number | null): string {
+  if (!body) return '';
+
+  // Remove excessive whitespace
+  let cleaned = body
+    .replace(/\r\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .replace(/[ \t]+/g, ' ')
+    .trim();
+
+  // Truncate if needed
+  if (maxLength && cleaned.length > maxLength) {
+    cleaned = cleaned.slice(0, maxLength) + '...';
+  }
+
+  return cleaned;
+}

package/lib/attachments.ts

@@ -0,0 +1,199 @@
+import fs from 'fs';
+import path from 'path';
+import { getGmail, output, decodeBase64Url, type OutputOptions, type MessagePayload } from './api';
+
+/** Attachment info */
+export interface AttachmentInfo {
+  filename: string;
+  mimeType?: string;
+  size: number;
+  attachmentId?: string | null;
+  partId?: string;
+}
+
+/** Download result */
+export interface DownloadResult {
+  ok: boolean;
+  filename: string;
+  savedTo?: string;
+  size?: number;
+  error?: string;
+}
+
+/** Download all result */
+export interface DownloadAllResult {
+  ok: boolean;
+  message?: string;
+  downloaded: DownloadResult[];
+}
+
+/**
+ * Extract attachment info from message payload
+ */
+function extractAttachmentInfo(payload: MessagePayload | undefined, attachments: AttachmentInfo[] = []): AttachmentInfo[] {
+  if (!payload) return attachments;
+
+  // Check if this part is an attachment
+  if (payload.filename && payload.filename.length > 0) {
+    attachments.push({
+      filename: payload.filename,
+      mimeType: payload.mimeType,
+      size: payload.body?.size || 0,
+      attachmentId: payload.body?.attachmentId || null,
+      partId: payload.partId
+    });
+  }
+
+  // Recursively check parts
+  if (payload.parts) {
+    for (const part of payload.parts) {
+      extractAttachmentInfo(part, attachments);
+    }
+  }
+
+  return attachments;
+}
+
+/**
+ * List attachments in a message
+ */
+export async function list(messageId: string, options: OutputOptions = {}): Promise<AttachmentInfo[]> {
+  const gmail = await getGmail();
+
+  const res = await gmail.users.messages.get({
+    userId: 'me',
+    id: messageId,
+    format: 'full'
+  });
+
+  const attachments = extractAttachmentInfo(res.data.payload as MessagePayload);
+
+  output(attachments, options);
+  return attachments;
+}
+
+/**
+ * Download an attachment
+ */
+export async function download(messageId: string, filename?: string, outputPath?: string, options: OutputOptions = {}): Promise<DownloadResult> {
+  const gmail = await getGmail();
+
+  // Get message to find attachment
+  const res = await gmail.users.messages.get({
+    userId: 'me',
+    id: messageId,
+    format: 'full'
+  });
+
+  const attachments = extractAttachmentInfo(res.data.payload as MessagePayload);
+
+  // Find the attachment by filename (or get first if not specified)
+  let attachment: AttachmentInfo | undefined;
+  if (filename) {
+    attachment = attachments.find(a =>
+      a.filename.toLowerCase() === filename.toLowerCase() ||
+      a.filename.toLowerCase().includes(filename.toLowerCase())
+    );
+  } else if (attachments.length === 1) {
+    attachment = attachments[0];
+  }
+
+  if (!attachment) {
+    throw new Error(`Attachment not found: ${filename || '(no attachments)'}`);
+  }
+
+  if (!attachment.attachmentId) {
+    throw new Error(`Attachment ${attachment.filename} has no downloadable content`);
+  }
+
+  // Get the attachment data
+  const attachmentRes = await gmail.users.messages.attachments.get({
+    userId: 'me',
+    messageId: messageId,
+    id: attachment.attachmentId
+  });
+
+  // Decode and save
+  const data = decodeBase64Url(attachmentRes.data.data);
+  const savePath = outputPath || attachment.filename;
+
+  fs.writeFileSync(savePath, data, 'binary');
+
+  const result: DownloadResult = {
+    ok: true,
+    filename: attachment.filename,
+    savedTo: path.resolve(savePath),
+    size: attachment.size
+  };
+
+  output(result, options);
+  return result;
+}
+
+/**
+ * Download all attachments from a message
+ */
+export async function downloadAll(messageId: string, outputDir?: string, options: OutputOptions = {}): Promise<DownloadAllResult> {
+  const gmail = await getGmail();
+
+  // Ensure output directory exists
+  const dir = outputDir || '.';
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  // Get message
+  const res = await gmail.users.messages.get({
+    userId: 'me',
+    id: messageId,
+    format: 'full'
+  });
+
+  const attachments = extractAttachmentInfo(res.data.payload as MessagePayload);
+
+  if (attachments.length === 0) {
+    const result: DownloadAllResult = { ok: true, message: 'No attachments found', downloaded: [] };
+    output(result, options);
+    return result;
+  }
+
+  const downloaded: DownloadResult[] = [];
+
+  for (const attachment of attachments) {
+    if (!attachment.attachmentId) continue;
+
+    try {
+      const attachmentRes = await gmail.users.messages.attachments.get({
+        userId: 'me',
+        messageId: messageId,
+        id: attachment.attachmentId
+      });
+
+      const data = decodeBase64Url(attachmentRes.data.data);
+      const savePath = path.join(dir, attachment.filename);
+
+      fs.writeFileSync(savePath, data, 'binary');
+
+      downloaded.push({
+        ok: true,
+        filename: attachment.filename,
+        savedTo: path.resolve(savePath),
+        size: attachment.size
+      });
+    } catch (err) {
+      downloaded.push({
+        ok: false,
+        filename: attachment.filename,
+        error: (err as Error).message
+      });
+    }
+  }
+
+  const result: DownloadAllResult = {
+    ok: true,
+    downloaded
+  };
+
+  output(result, options);
+  return result;
+}