@cli4ai/gmail 1.0.6 → 1.0.8

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

package/lib/drafts.ts

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