@cli4ai/gmail 1.0.4 → 1.0.6

package/lib/send.ts

@@ -0,0 +1,331 @@
+import { getGmail, output, encodeBase64Url, extractHeaders, extractBody, type OutputOptions, type MessagePayload } from './api';
+import { createMultipartMessage, createSimpleMessage } from './drafts';
+
+/** Send result */
+export interface SendResult {
+  ok: boolean;
+  id?: string;
+  threadId?: string;
+  to?: string;
+  subject?: string;
+  inReplyTo?: string;
+  forwardedFrom?: string;
+}
+
+/** Send options */
+export interface SendOptions extends OutputOptions {
+  cc?: string;
+  bcc?: string;
+  attach?: string | string[];
+}
+
+/**
+ * Create raw email message
+ */
+function createRawMessage({ 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'));
+}
+
+/**
+ * Send a new email
+ */
+export async function send(to: string, subject: string, body: string, options: SendOptions = {}): Promise<SendResult> {
+  const gmail = await getGmail();
+
+  // Process newlines in body
+  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 = createRawMessage({
+      to,
+      cc: options.cc,
+      bcc: options.bcc,
+      subject,
+      body
+    });
+  }
+
+  const res = await gmail.users.messages.send({
+    userId: 'me',
+    requestBody: { raw }
+  });
+
+  const result: SendResult = {
+    ok: true,
+    id: res.data.id || undefined,
+    threadId: res.data.threadId || undefined,
+    to,
+    subject
+  };
+
+  output(result, options);
+  return result;
+}
+
+/**
+ * Reply to a message
+ */
+export async function reply(messageId: string, body: string, options: SendOptions = {}): Promise<SendResult> {
+  const gmail = await getGmail();
+
+  // Get original message to extract headers
+  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 who to reply to
+  const replyTo = headers.from!;
+  let subject = headers.subject || '';
+  if (!subject.toLowerCase().startsWith('re:')) {
+    subject = `Re: ${subject}`;
+  }
+
+  // Process newlines in body
+  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 = createRawMessage({
+      to: replyTo,
+      subject,
+      body,
+      inReplyTo: headers.message_id,
+      references: headers.references ? `${headers.references} ${headers.message_id}` : headers.message_id
+    });
+  }
+
+  const res = await gmail.users.messages.send({
+    userId: 'me',
+    requestBody: {
+      raw,
+      threadId: original.data.threadId || undefined
+    }
+  });
+
+  const result: SendResult = {
+    ok: true,
+    id: res.data.id || undefined,
+    threadId: res.data.threadId || undefined,
+    to: replyTo,
+    subject,
+    inReplyTo: messageId
+  };
+
+  output(result, options);
+  return result;
+}
+
+/**
+ * Reply all
+ */
+export async function replyAll(messageId: string, body: string, options: SendOptions = {}): Promise<SendResult> {
+  const gmail = await getGmail();
+
+  // Get original message
+  const original = await gmail.users.messages.get({
+    userId: 'me',
+    id: messageId,
+    format: 'metadata',
+    metadataHeaders: ['From', 'To', 'Cc', 'Subject', 'Message-ID', 'References']
+  });
+
+  const headers = extractHeaders(original.data.payload?.headers as Array<{ name: string; value: string }>);
+
+  // Get my email address
+  const profile = await gmail.users.getProfile({ userId: 'me' });
+  const myEmail = profile.data.emailAddress!;
+
+  // Build recipient list (original From + all To/Cc, excluding myself)
+  const allRecipients = new Set<string>();
+  allRecipients.add(headers.from!);
+
+  if (headers.to) {
+    headers.to.split(',').forEach(email => allRecipients.add(email.trim()));
+  }
+  if (headers.cc) {
+    headers.cc.split(',').forEach(email => allRecipients.add(email.trim()));
+  }
+
+  // Remove myself from recipients
+  const recipients = Array.from(allRecipients).filter(
+    email => !email.toLowerCase().includes(myEmail.toLowerCase())
+  );
+
+  let subject = headers.subject || '';
+  if (!subject.toLowerCase().startsWith('re:')) {
+    subject = `Re: ${subject}`;
+  }
+
+  body = body.replace(/\\n/g, '\n');
+
+  const raw = createRawMessage({
+    to: recipients.join(', '),
+    subject,
+    body,
+    inReplyTo: headers.message_id,
+    references: headers.references ? `${headers.references} ${headers.message_id}` : headers.message_id
+  });
+
+  const res = await gmail.users.messages.send({
+    userId: 'me',
+    requestBody: {
+      raw,
+      threadId: original.data.threadId || undefined
+    }
+  });
+
+  const result: SendResult = {
+    ok: true,
+    id: res.data.id || undefined,
+    threadId: res.data.threadId || undefined,
+    to: recipients.join(', '),
+    subject,
+    inReplyTo: messageId
+  };
+
+  output(result, options);
+  return result;
+}
+
+/**
+ * Forward a message
+ */
+export async function forward(messageId: string, to: string, body?: string, options: OutputOptions = {}): Promise<SendResult> {
+  const gmail = await getGmail();
+
+  // Get original message with full body
+  const original = await gmail.users.messages.get({
+    userId: 'me',
+    id: messageId,
+    format: 'full'
+  });
+
+  const headers = extractHeaders(original.data.payload?.headers as Array<{ name: string; value: string }>);
+  const originalBody = extractBody(original.data.payload as MessagePayload);
+
+  let subject = headers.subject || '';
+  if (!subject.toLowerCase().startsWith('fwd:')) {
+    subject = `Fwd: ${subject}`;
+  }
+
+  // Build forwarded message body
+  const forwardedContent = [
+    body ? body.replace(/\\n/g, '\n') : '',
+    '',
+    '---------- Forwarded message ----------',
+    `From: ${headers.from}`,
+    `Date: ${headers.date}`,
+    `Subject: ${headers.subject}`,
+    `To: ${headers.to}`,
+    '',
+    originalBody
+  ].join('\n');
+
+  const raw = createRawMessage({
+    to,
+    subject,
+    body: forwardedContent
+  });
+
+  const res = await gmail.users.messages.send({
+    userId: 'me',
+    requestBody: { raw }
+  });
+
+  const result: SendResult = {
+    ok: true,
+    id: res.data.id || undefined,
+    threadId: res.data.threadId || undefined,
+    to,
+    subject,
+    forwardedFrom: messageId
+  };
+
+  output(result, options);
+  return result;
+}
+
+/**
+ * Create draft
+ */
+export async function draft(to: string, subject: string, body: string, options: SendOptions = {}): Promise<SendResult> {
+  const gmail = await getGmail();
+
+  body = body.replace(/\\n/g, '\n');
+
+  const raw = createRawMessage({
+    to,
+    cc: options.cc,
+    subject,
+    body
+  });
+
+  const res = await gmail.users.drafts.create({
+    userId: 'me',
+    requestBody: {
+      message: { raw }
+    }
+  });
+
+  const result: SendResult = {
+    ok: true,
+    id: res.data.id || undefined,
+    to,
+    subject
+  };
+
+  output(result, options);
+  return result;
+}

package/lib/threads.ts

@@ -0,0 +1,164 @@
+import { getGmail, output, formatDate, extractHeaders, extractBody, cleanBody, type OutputOptions, type MessagePayload } from './api';
+
+/** Thread message */
+export interface ThreadMessage {
+  id: string;
+  date: string | null;
+  from: string;
+  to: string;
+  subject: string;
+  body: string;
+}
+
+/** Thread data */
+export interface ThreadData {
+  id: string;
+  subject: string;
+  messageCount: number;
+  messages: ThreadMessage[];
+}
+
+/** Thread summary */
+export interface ThreadSummary {
+  id: string;
+  subject: string;
+  from: string;
+  lastFrom: string;
+  date: string | null;
+  messageCount: number;
+  snippet: string;
+}
+
+/** Thread action result */
+export interface ThreadActionResult {
+  ok: boolean;
+  archived?: string;
+  trashed?: string;
+}
+
+/** Thread options */
+export interface ThreadOptions extends OutputOptions {
+  fullBody?: boolean;
+  limit?: number;
+  query?: string;
+}
+
+/**
+ * Get full thread (conversation)
+ */
+export async function get(threadId: string, options: ThreadOptions = {}): Promise<ThreadData> {
+  const gmail = await getGmail();
+
+  const res = await gmail.users.threads.get({
+    userId: 'me',
+    id: threadId,
+    format: 'full'
+  });
+
+  const messages: ThreadMessage[] = (res.data.messages || []).map(msg => {
+    const headers = extractHeaders(msg.payload?.headers as Array<{ name: string; value: string }>);
+    return {
+      id: msg.id!,
+      date: formatDate(msg.internalDate),
+      from: headers.from || '',
+      to: headers.to || '',
+      subject: headers.subject || '(no subject)',
+      body: cleanBody(extractBody(msg.payload as MessagePayload), options.fullBody ? null : 2000)
+    };
+  });
+
+  const thread: ThreadData = {
+    id: res.data.id!,
+    subject: messages[0]?.subject || '(no subject)',
+    messageCount: messages.length,
+    messages: messages
+  };
+
+  output(thread, options);
+  return thread;
+}
+
+/**
+ * List recent threads
+ */
+export async function list(options: ThreadOptions = {}): Promise<ThreadSummary[]> {
+  const gmail = await getGmail();
+  const limit = options.limit || 20;
+  const query = options.query || '';
+
+  const res = await gmail.users.threads.list({
+    userId: 'me',
+    maxResults: limit,
+    q: query
+  });
+
+  if (!res.data.threads || res.data.threads.length === 0) {
+    output([], options);
+    return [];
+  }
+
+  // Get summary of each thread
+  const threads = await Promise.all(
+    res.data.threads.map(async (thread) => {
+      const threadData = await gmail.users.threads.get({
+        userId: 'me',
+        id: thread.id!,
+        format: 'metadata',
+        metadataHeaders: ['From', 'Subject', 'Date']
+      });
+
+      const firstMsg = threadData.data.messages?.[0];
+      const lastMsg = threadData.data.messages?.[threadData.data.messages.length - 1];
+      const firstHeaders = extractHeaders(firstMsg?.payload?.headers as Array<{ name: string; value: string }>);
+      const lastHeaders = extractHeaders(lastMsg?.payload?.headers as Array<{ name: string; value: string }>);
+
+      return {
+        id: thread.id!,
+        subject: firstHeaders.subject || '(no subject)',
+        from: firstHeaders.from || '',
+        lastFrom: lastHeaders.from || '',
+        date: formatDate(lastMsg?.internalDate),
+        messageCount: threadData.data.messages?.length || 0,
+        snippet: thread.snippet || ''
+      };
+    })
+  );
+
+  output(threads, options);
+  return threads;
+}
+
+/**
+ * Archive entire thread
+ */
+export async function archive(threadId: string, options: OutputOptions = {}): Promise<ThreadActionResult> {
+  const gmail = await getGmail();
+
+  await gmail.users.threads.modify({
+    userId: 'me',
+    id: threadId,
+    requestBody: {
+      removeLabelIds: ['INBOX']
+    }
+  });
+
+  const result: ThreadActionResult = { ok: true, archived: threadId };
+  output(result, options);
+  return result;
+}
+
+/**
+ * Trash entire thread
+ */
+export async function trash(threadId: string, options: OutputOptions = {}): Promise<ThreadActionResult> {
+  const gmail = await getGmail();
+
+  await gmail.users.threads.trash({
+    userId: 'me',
+    id: threadId
+  });
+
+  const result: ThreadActionResult = { ok: true, trashed: threadId };
+  output(result, options);
+  return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cli4ai/gmail",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Gmail CLI tool for messages, threads, and drafts",
   "author": "cliforai",
   "license": "MIT",
@@ -28,6 +28,7 @@
     "url": "https://github.com/cliforai/packages/issues"
   },
   "dependencies": {
+    "@cli4ai/lib": "^1.0.2",
     "googleapis": "^144.0.0",
     "google-auth-library": "^9.0.0",
     "commander": "^14.0.0"
@@ -35,6 +36,7 @@
   "files": [
     "run.ts",
     "cli4ai.json",
+    "lib/**/*",
     "README.md",
     "LICENSE"
   ],