@cli4ai/gmail 1.0.11 → 1.0.14

package/dist/lib/messages.js

@@ -0,0 +1,223 @@
+import { getGmail, output, formatDate, extractHeaders, extractBody, cleanBody } from './api.js';
+/**
+ * List inbox messages
+ */
+export async function inbox(options = {}) {
+    const gmail = await getGmail();
+    const limit = options.limit || 20;
+    const res = await gmail.users.messages.list({
+        userId: 'me',
+        maxResults: limit,
+        labelIds: ['INBOX']
+    });
+    if (!res.data.messages || res.data.messages.length === 0) {
+        output([], options);
+        return [];
+    }
+    const messages = await Promise.all(res.data.messages.map(msg => getMessageSummary(gmail, msg.id, options)));
+    output(messages, options);
+    return messages;
+}
+/**
+ * List unread messages
+ */
+export async function unread(options = {}) {
+    const gmail = await getGmail();
+    const limit = options.limit || 20;
+    const res = await gmail.users.messages.list({
+        userId: 'me',
+        maxResults: limit,
+        q: 'is:unread'
+    });
+    if (!res.data.messages || res.data.messages.length === 0) {
+        output([], options);
+        return [];
+    }
+    const messages = await Promise.all(res.data.messages.map(msg => getMessageSummary(gmail, msg.id, options)));
+    output(messages, options);
+    return messages;
+}
+/**
+ * Search messages with Gmail query syntax
+ */
+export async function search(query, options = {}) {
+    const gmail = await getGmail();
+    const limit = options.limit || 20;
+    const res = await gmail.users.messages.list({
+        userId: 'me',
+        maxResults: limit,
+        q: query
+    });
+    if (!res.data.messages || res.data.messages.length === 0) {
+        output([], options);
+        return [];
+    }
+    const messages = await Promise.all(res.data.messages.map(msg => getMessageSummary(gmail, msg.id, options)));
+    output(messages, options);
+    return messages;
+}
+/**
+ * Get message summary (for list views)
+ */
+async function getMessageSummary(gmail, messageId, options = {}) {
+    const res = await gmail.users.messages.get({
+        userId: 'me',
+        id: messageId,
+        format: options.body ? 'full' : 'metadata',
+        metadataHeaders: ['From', 'To', 'Subject', 'Date']
+    });
+    const headers = extractHeaders(res.data.payload?.headers);
+    const labels = res.data.labelIds || [];
+    const summary = {
+        id: res.data.id,
+        threadId: res.data.threadId || undefined,
+        date: formatDate(res.data.internalDate),
+        from: headers.from || '',
+        to: headers.to || '',
+        subject: headers.subject || '(no subject)',
+        snippet: res.data.snippet || '',
+        labels: labels,
+        unread: labels.includes('UNREAD'),
+        starred: labels.includes('STARRED'),
+        important: labels.includes('IMPORTANT')
+    };
+    if (options.body) {
+        summary.body = cleanBody(extractBody(res.data.payload), 1000);
+    }
+    return summary;
+}
+/**
+ * Read a full message
+ */
+export async function read(messageId, options = {}) {
+    const gmail = await getGmail();
+    const res = await gmail.users.messages.get({
+        userId: 'me',
+        id: messageId,
+        format: 'full'
+    });
+    const headers = extractHeaders(res.data.payload?.headers);
+    const labels = res.data.labelIds || [];
+    const body = extractBody(res.data.payload);
+    const message = {
+        id: res.data.id,
+        threadId: res.data.threadId || undefined,
+        date: formatDate(res.data.internalDate),
+        from: headers.from || '',
+        to: headers.to || '',
+        cc: headers.cc || null,
+        subject: headers.subject || '(no subject)',
+        body: body,
+        labels: labels,
+        unread: labels.includes('UNREAD'),
+        starred: labels.includes('STARRED')
+    };
+    output(message, options);
+    return message;
+}
+/**
+ * Archive a message (remove from INBOX)
+ */
+export async function archive(messageId, options = {}) {
+    const gmail = await getGmail();
+    await gmail.users.messages.modify({
+        userId: 'me',
+        id: messageId,
+        requestBody: {
+            removeLabelIds: ['INBOX']
+        }
+    });
+    const result = { ok: true, archived: messageId };
+    output(result, options);
+    return result;
+}
+/**
+ * Trash a message
+ */
+export async function trash(messageId, options = {}) {
+    const gmail = await getGmail();
+    await gmail.users.messages.trash({
+        userId: 'me',
+        id: messageId
+    });
+    const result = { ok: true, trashed: messageId };
+    output(result, options);
+    return result;
+}
+/**
+ * Untrash a message
+ */
+export async function untrash(messageId, options = {}) {
+    const gmail = await getGmail();
+    await gmail.users.messages.untrash({
+        userId: 'me',
+        id: messageId
+    });
+    const result = { ok: true, untrashed: messageId };
+    output(result, options);
+    return result;
+}
+/**
+ * Star a message
+ */
+export async function star(messageId, options = {}) {
+    const gmail = await getGmail();
+    await gmail.users.messages.modify({
+        userId: 'me',
+        id: messageId,
+        requestBody: {
+            addLabelIds: ['STARRED']
+        }
+    });
+    const result = { ok: true, starred: messageId };
+    output(result, options);
+    return result;
+}
+/**
+ * Unstar a message
+ */
+export async function unstar(messageId, options = {}) {
+    const gmail = await getGmail();
+    await gmail.users.messages.modify({
+        userId: 'me',
+        id: messageId,
+        requestBody: {
+            removeLabelIds: ['STARRED']
+        }
+    });
+    const result = { ok: true, unstarred: messageId };
+    output(result, options);
+    return result;
+}
+/**
+ * Mark as read
+ */
+export async function markRead(messageId, options = {}) {
+    const gmail = await getGmail();
+    await gmail.users.messages.modify({
+        userId: 'me',
+        id: messageId,
+        requestBody: {
+            removeLabelIds: ['UNREAD']
+        }
+    });
+    const result = { ok: true, markedRead: messageId };
+    output(result, options);
+    return result;
+}
+/**
+ * Mark as unread
+ */
+export async function markUnread(messageId, options = {}) {
+    const gmail = await getGmail();
+    await gmail.users.messages.modify({
+        userId: 'me',
+        id: messageId,
+        requestBody: {
+            addLabelIds: ['UNREAD']
+        }
+    });
+    const result = { ok: true, markedUnread: messageId };
+    output(result, options);
+    return result;
+}

package/dist/lib/send.d.ts

@@ -0,0 +1,37 @@
+import { type OutputOptions } from './api.js';
+/** 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[];
+}
+/**
+ * Send a new email
+ */
+export declare function send(to: string, subject: string, body: string, options?: SendOptions): Promise<SendResult>;
+/**
+ * Reply to a message
+ */
+export declare function reply(messageId: string, body: string, options?: SendOptions): Promise<SendResult>;
+/**
+ * Reply all
+ */
+export declare function replyAll(messageId: string, body: string, options?: SendOptions): Promise<SendResult>;
+/**
+ * Forward a message
+ */
+export declare function forward(messageId: string, to: string, body?: string, options?: OutputOptions): Promise<SendResult>;
+/**
+ * Create draft
+ */
+export declare function draft(to: string, subject: string, body: string, options?: SendOptions): Promise<SendResult>;

package/dist/lib/send.js

@@ -0,0 +1,259 @@
+import { getGmail, output, encodeBase64Url, extractHeaders, extractBody } from './api.js';
+import { createMultipartMessage } from './drafts.js';
+/**
+ * Create raw email message
+ */
+function createRawMessage({ to, cc, bcc, subject, body, inReplyTo, references }) {
+    const lines = [];
+    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, subject, body, options = {}) {
+    const gmail = await getGmail();
+    // Process newlines in body
+    body = body.replace(/\\n/g, '\n');
+    let raw;
+    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 = {
+        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, body, options = {}) {
+    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);
+    // 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;
+    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 = {
+        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, body, options = {}) {
+    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);
+    // 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();
+    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 = {
+        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, to, body, options = {}) {
+    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);
+    const originalBody = extractBody(original.data.payload);
+    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 = {
+        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, subject, body, options = {}) {
+    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 = {
+        ok: true,
+        id: res.data.id || undefined,
+        to,
+        subject
+    };
+    output(result, options);
+    return result;
+}

package/dist/lib/threads.d.ts

@@ -0,0 +1,55 @@
+import { type OutputOptions } from './api.js';
+/** 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 declare function get(threadId: string, options?: ThreadOptions): Promise<ThreadData>;
+/**
+ * List recent threads
+ */
+export declare function list(options?: ThreadOptions): Promise<ThreadSummary[]>;
+/**
+ * Archive entire thread
+ */
+export declare function archive(threadId: string, options?: OutputOptions): Promise<ThreadActionResult>;
+/**
+ * Trash entire thread
+ */
+export declare function trash(threadId: string, options?: OutputOptions): Promise<ThreadActionResult>;

package/dist/lib/threads.js

@@ -0,0 +1,101 @@
+import { getGmail, output, formatDate, extractHeaders, extractBody, cleanBody } from './api.js';
+/**
+ * Get full thread (conversation)
+ */
+export async function get(threadId, options = {}) {
+    const gmail = await getGmail();
+    const res = await gmail.users.threads.get({
+        userId: 'me',
+        id: threadId,
+        format: 'full'
+    });
+    const messages = (res.data.messages || []).map(msg => {
+        const headers = extractHeaders(msg.payload?.headers);
+        return {
+            id: msg.id,
+            date: formatDate(msg.internalDate),
+            from: headers.from || '',
+            to: headers.to || '',
+            subject: headers.subject || '(no subject)',
+            body: cleanBody(extractBody(msg.payload), options.fullBody ? null : 2000)
+        };
+    });
+    const thread = {
+        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 = {}) {
+    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);
+        const lastHeaders = extractHeaders(lastMsg?.payload?.headers);
+        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, options = {}) {
+    const gmail = await getGmail();
+    await gmail.users.threads.modify({
+        userId: 'me',
+        id: threadId,
+        requestBody: {
+            removeLabelIds: ['INBOX']
+        }
+    });
+    const result = { ok: true, archived: threadId };
+    output(result, options);
+    return result;
+}
+/**
+ * Trash entire thread
+ */
+export async function trash(threadId, options = {}) {
+    const gmail = await getGmail();
+    await gmail.users.threads.trash({
+        userId: 'me',
+        id: threadId
+    });
+    const result = { ok: true, trashed: threadId };
+    output(result, options);
+    return result;
+}

package/dist/run.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};