@cli4ai/gmail 1.0.5 → 1.0.7

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;
+}

package/lib/drafts.ts

@@ -0,0 +1,434 @@
+import fs from 'fs';
+import path from 'path';
+import { getGmail, output, formatDate, encodeBase64Url, extractHeaders, extractBody, type OutputOptions, type MessagePayload } from './api';
+
+/** Attachment path */
+export interface AttachmentPath {
+  path: string;
+  mimeType?: string;
+}
+
+/** Draft data */
+export interface DraftData {
+  id: string;
+  messageId?: string;
+  threadId?: string;
+  to: string;
+  cc?: string | null;
+  subject: string;
+  snippet?: string;
+  body?: string;
+}
+
+/** Draft result */
+export interface DraftResult {
+  ok: boolean;
+  id?: string;
+  messageId?: string;
+  threadId?: string;
+  to?: string;
+  subject?: string;
+  inReplyTo?: string;
+  deleted?: string;
+  sentDraft?: string;
+}
+
+/** Draft options */
+export interface DraftOptions extends OutputOptions {
+  cc?: string;
+  bcc?: string;
+  attach?: string | string[];
+  limit?: number;
+}
+
+/**
+ * Create multipart message with attachment
+ */
+export function createMultipartMessage({ to, cc, bcc, subject, body, inReplyTo, references, attachments = [] }: {
+  to: string;
+  cc?: string;
+  bcc?: string;
+  subject: string;
+  body: string;
+  inReplyTo?: string;
+  references?: string;
+  attachments?: AttachmentPath[];
+}): string {
+  const boundary = `boundary_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+  const headers: string[] = [];
+  headers.push(`To: ${to}`);
+  if (cc) headers.push(`Cc: ${cc}`);
+  if (bcc) headers.push(`Bcc: ${bcc}`);
+  headers.push(`Subject: ${subject}`);
+  if (inReplyTo) {
+    headers.push(`In-Reply-To: ${inReplyTo}`);
+    headers.push(`References: ${references || inReplyTo}`);
+  }
+  headers.push('MIME-Version: 1.0');
+  headers.push(`Content-Type: multipart/mixed; boundary="${boundary}"`);
+
+  const parts: string[] = [];
+
+  // Text body part
+  parts.push(`--${boundary}`);
+  parts.push('Content-Type: text/plain; charset=utf-8');
+  parts.push('Content-Transfer-Encoding: 7bit');
+  parts.push('');
+  parts.push(body);
+
+  // Attachment parts
+  for (const att of attachments) {
+    const filename = path.basename(att.path);
+    const content = fs.readFileSync(att.path);
+    const base64Content = content.toString('base64');
+    const mimeType = att.mimeType || getMimeType(filename);
+
+    parts.push(`--${boundary}`);
+    parts.push(`Content-Type: ${mimeType}; name="${filename}"`);
+    parts.push('Content-Transfer-Encoding: base64');
+    parts.push(`Content-Disposition: attachment; filename="${filename}"`);
+    parts.push('');
+    // Split base64 into lines of 76 chars
+    for (let i = 0; i < base64Content.length; i += 76) {
+      parts.push(base64Content.slice(i, i + 76));
+    }
+  }
+
+  parts.push(`--${boundary}--`);
+
+  const message = headers.join('\r\n') + '\r\n\r\n' + parts.join('\r\n');
+  return encodeBase64Url(message);
+}
+
+/**
+ * Simple message without attachments
+ */
+export function createSimpleMessage({ to, cc, bcc, subject, body, inReplyTo, references }: {
+  to: string;
+  cc?: string;
+  bcc?: string;
+  subject: string;
+  body: string;
+  inReplyTo?: string;
+  references?: string;
+}): string {
+  const lines: string[] = [];
+  lines.push(`To: ${to}`);
+  if (cc) lines.push(`Cc: ${cc}`);
+  if (bcc) lines.push(`Bcc: ${bcc}`);
+  lines.push(`Subject: ${subject}`);
+  lines.push('Content-Type: text/plain; charset=utf-8');
+  if (inReplyTo) {
+    lines.push(`In-Reply-To: ${inReplyTo}`);
+    lines.push(`References: ${references || inReplyTo}`);
+  }
+  lines.push('');
+  lines.push(body);
+  return encodeBase64Url(lines.join('\r\n'));
+}
+
+/**
+ * Get MIME type from filename
+ */
+function getMimeType(filename: string): string {
+  const ext = path.extname(filename).toLowerCase();
+  const mimeTypes: Record<string, string> = {
+    '.pdf': 'application/pdf',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.txt': 'text/plain',
+    '.csv': 'text/csv',
+    '.zip': 'application/zip',
+    '.json': 'application/json',
+    '.xml': 'application/xml',
+    '.html': 'text/html'
+  };
+  return mimeTypes[ext] || 'application/octet-stream';
+}
+
+/**
+ * List all drafts
+ */
+export async function list(options: DraftOptions = {}): Promise<DraftData[]> {
+  const gmail = await getGmail();
+  const limit = options.limit || 20;
+
+  const res = await gmail.users.drafts.list({
+    userId: 'me',
+    maxResults: limit
+  });
+
+  if (!res.data.drafts || res.data.drafts.length === 0) {
+    output([], options);
+    return [];
+  }
+
+  // Get details for each draft
+  const drafts = await Promise.all(
+    res.data.drafts.map(async (draft) => {
+      const draftRes = await gmail.users.drafts.get({
+        userId: 'me',
+        id: draft.id!,
+        format: 'metadata',
+        metadataHeaders: ['To', 'Subject', 'Date']
+      });
+
+      const headers = extractHeaders(draftRes.data.message?.payload?.headers as Array<{ name: string; value: string }>);
+
+      return {
+        id: draft.id!,
+        messageId: draftRes.data.message?.id,
+        to: headers.to || '(no recipient)',
+        subject: headers.subject || '(no subject)',
+        snippet: draftRes.data.message?.snippet || ''
+      };
+    })
+  );
+
+  output(drafts, options);
+  return drafts;
+}
+
+/**
+ * Get a draft
+ */
+export async function get(draftId: string, options: OutputOptions = {}): Promise<DraftData> {
+  const gmail = await getGmail();
+
+  const res = await gmail.users.drafts.get({
+    userId: 'me',
+    id: draftId,
+    format: 'full'
+  });
+
+  const headers = extractHeaders(res.data.message?.payload?.headers as Array<{ name: string; value: string }>);
+  const body = extractBody(res.data.message?.payload as MessagePayload);
+
+  const draft: DraftData = {
+    id: res.data.id!,
+    messageId: res.data.message?.id,
+    threadId: res.data.message?.threadId || undefined,
+    to: headers.to || '',
+    cc: headers.cc || null,
+    subject: headers.subject || '(no subject)',
+    body: body
+  };
+
+  output(draft, options);
+  return draft;
+}
+
+/**
+ * Create a new draft
+ */
+export async function create(to: string, subject: string, body: string, options: DraftOptions = {}): Promise<DraftResult> {
+  const gmail = await getGmail();
+
+  body = body.replace(/\\n/g, '\n');
+
+  let raw: string;
+  if (options.attach) {
+    const attachments = Array.isArray(options.attach) ? options.attach : [options.attach];
+    const attachmentPaths = attachments.map(a => ({ path: a }));
+    raw = createMultipartMessage({
+      to,
+      cc: options.cc,
+      bcc: options.bcc,
+      subject,
+      body,
+      attachments: attachmentPaths
+    });
+  } else {
+    raw = createSimpleMessage({
+      to,
+      cc: options.cc,
+      bcc: options.bcc,
+      subject,
+      body
+    });
+  }
+
+  const res = await gmail.users.drafts.create({
+    userId: 'me',
+    requestBody: {
+      message: { raw }
+    }
+  });
+
+  const result: DraftResult = {
+    ok: true,
+    id: res.data.id || undefined,
+    messageId: res.data.message?.id,
+    to,
+    subject
+  };
+
+  output(result, options);
+  return result;
+}
+
+/**
+ * Create a draft reply to a message
+ */
+export async function createReply(messageId: string, body: string, options: DraftOptions = {}): Promise<DraftResult> {
+  const gmail = await getGmail();
+
+  // Get original message
+  const original = await gmail.users.messages.get({
+    userId: 'me',
+    id: messageId,
+    format: 'metadata',
+    metadataHeaders: ['From', 'To', 'Subject', 'Message-ID', 'References']
+  });
+
+  const headers = extractHeaders(original.data.payload?.headers as Array<{ name: string; value: string }>);
+
+  // Determine reply-to address
+  const replyTo = headers.from!;
+  let subject = headers.subject || '';
+  if (!subject.toLowerCase().startsWith('re:')) {
+    subject = `Re: ${subject}`;
+  }
+
+  body = body.replace(/\\n/g, '\n');
+
+  let raw: string;
+  if (options.attach) {
+    const attachments = Array.isArray(options.attach) ? options.attach : [options.attach];
+    const attachmentPaths = attachments.map(a => ({ path: a }));
+    raw = createMultipartMessage({
+      to: replyTo,
+      subject,
+      body,
+      inReplyTo: headers.message_id,
+      references: headers.references ? `${headers.references} ${headers.message_id}` : headers.message_id,
+      attachments: attachmentPaths
+    });
+  } else {
+    raw = createSimpleMessage({
+      to: replyTo,
+      subject,
+      body,
+      inReplyTo: headers.message_id,
+      references: headers.references ? `${headers.references} ${headers.message_id}` : headers.message_id
+    });
+  }
+
+  const res = await gmail.users.drafts.create({
+    userId: 'me',
+    requestBody: {
+      message: {
+        raw,
+        threadId: original.data.threadId || undefined
+      }
+    }
+  });
+
+  const result: DraftResult = {
+    ok: true,
+    id: res.data.id || undefined,
+    messageId: res.data.message?.id,
+    threadId: original.data.threadId || undefined,
+    to: replyTo,
+    subject,
+    inReplyTo: messageId
+  };
+
+  output(result, options);
+  return result;
+}
+
+/**
+ * Update a draft
+ */
+export async function update(draftId: string, to: string, subject: string, body: string, options: DraftOptions = {}): Promise<DraftResult> {
+  const gmail = await getGmail();
+
+  body = body.replace(/\\n/g, '\n');
+
+  let raw: string;
+  if (options.attach) {
+    const attachments = Array.isArray(options.attach) ? options.attach : [options.attach];
+    const attachmentPaths = attachments.map(a => ({ path: a }));
+    raw = createMultipartMessage({
+      to,
+      cc: options.cc,
+      subject,
+      body,
+      attachments: attachmentPaths
+    });
+  } else {
+    raw = createSimpleMessage({
+      to,
+      cc: options.cc,
+      subject,
+      body
+    });
+  }
+
+  const res = await gmail.users.drafts.update({
+    userId: 'me',
+    id: draftId,
+    requestBody: {
+      message: { raw }
+    }
+  });
+
+  const result: DraftResult = {
+    ok: true,
+    id: res.data.id || undefined,
+    messageId: res.data.message?.id,
+    to,
+    subject
+  };
+
+  output(result, options);
+  return result;
+}
+
+/**
+ * Delete a draft
+ */
+export async function remove(draftId: string, options: OutputOptions = {}): Promise<DraftResult> {
+  const gmail = await getGmail();
+
+  await gmail.users.drafts.delete({
+    userId: 'me',
+    id: draftId
+  });
+
+  const result: DraftResult = { ok: true, deleted: draftId };
+  output(result, options);
+  return result;
+}
+
+/**
+ * Send a draft
+ */
+export async function send(draftId: string, options: OutputOptions = {}): Promise<DraftResult> {
+  const gmail = await getGmail();
+
+  const res = await gmail.users.drafts.send({
+    userId: 'me',
+    requestBody: {
+      id: draftId
+    }
+  });
+
+  const result: DraftResult = {
+    ok: true,
+    id: res.data.id || undefined,
+    threadId: res.data.threadId || undefined,
+    sentDraft: draftId
+  };
+
+  output(result, options);
+  return result;
+}