@cli4ai/gmail 1.0.7 → 1.0.9

package/lib/api.ts

@@ -1,299 +0,0 @@
-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}. Run: cli4ai secrets init gmail`);
-  }
-
-  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

@@ -1,199 +0,0 @@
-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;
-}