@cli4ai/gmail 1.0.11 → 1.0.13

package/dist/lib/drafts.js

@@ -0,0 +1,334 @@
+import fs from 'fs';
+import path from 'path';
+import { getGmail, output, encodeBase64Url, extractHeaders, extractBody } from './api.js';
+/**
+ * Create multipart message with attachment
+ */
+export function createMultipartMessage({ to, cc, bcc, subject, body, inReplyTo, references, attachments = [] }) {
+    const boundary = `boundary_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const headers = [];
+    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 = [];
+    // 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 }) {
+    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'));
+}
+/**
+ * Get MIME type from filename
+ */
+function getMimeType(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    const mimeTypes = {
+        '.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 = {}) {
+    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 data = draftRes.data;
+        const headers = extractHeaders(data.message?.payload?.headers);
+        return {
+            id: draft.id,
+            messageId: data.message?.id,
+            to: headers.to || '(no recipient)',
+            subject: headers.subject || '(no subject)',
+            snippet: data.message?.snippet || ''
+        };
+    }));
+    output(drafts, options);
+    return drafts;
+}
+/**
+ * Get a draft
+ */
+export async function get(draftId, options = {}) {
+    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);
+    const body = extractBody(res.data.message?.payload);
+    const draft = {
+        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, subject, body, options = {}) {
+    const gmail = await getGmail();
+    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 = createSimpleMessage({
+            to,
+            cc: options.cc,
+            bcc: options.bcc,
+            subject,
+            body
+        });
+    }
+    const res = await gmail.users.drafts.create({
+        userId: 'me',
+        requestBody: {
+            message: { raw }
+        }
+    });
+    const result = {
+        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, 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', 'Subject', 'Message-ID', 'References']
+    });
+    const headers = extractHeaders(original.data.payload?.headers);
+    // 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;
+    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 = {
+        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, to, subject, body, options = {}) {
+    const gmail = await getGmail();
+    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,
+            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 = {
+        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, options = {}) {
+    const gmail = await getGmail();
+    await gmail.users.drafts.delete({
+        userId: 'me',
+        id: draftId
+    });
+    const result = { ok: true, deleted: draftId };
+    output(result, options);
+    return result;
+}
+/**
+ * Send a draft
+ */
+export async function send(draftId, options = {}) {
+    const gmail = await getGmail();
+    const res = await gmail.users.drafts.send({
+        userId: 'me',
+        requestBody: {
+            id: draftId
+        }
+    });
+    const result = {
+        ok: true,
+        id: res.data.id || undefined,
+        threadId: res.data.threadId || undefined,
+        sentDraft: draftId
+    };
+    output(result, options);
+    return result;
+}

package/dist/lib/labels.d.ts

@@ -0,0 +1,47 @@
+import { type OutputOptions } from './api.js';
+/** Label data */
+export interface LabelData {
+    id: string;
+    name: string;
+    type?: string;
+    messageListVisibility?: string;
+    labelListVisibility?: string;
+    messagesTotal?: number;
+    messagesUnread?: number;
+    threadsTotal?: number;
+    threadsUnread?: number;
+}
+/** Label action result */
+export interface LabelActionResult {
+    ok: boolean;
+    id?: string;
+    name?: string;
+    messageId?: string;
+    labelAdded?: string;
+    labelRemoved?: string;
+    deleted?: string;
+}
+/**
+ * List all labels
+ */
+export declare function list(options?: OutputOptions): Promise<LabelData[]>;
+/**
+ * Get label details with counts
+ */
+export declare function get(labelId: string, options?: OutputOptions): Promise<LabelData>;
+/**
+ * Add label to message
+ */
+export declare function addToMessage(messageId: string, labelName: string, options?: OutputOptions): Promise<LabelActionResult>;
+/**
+ * Remove label from message
+ */
+export declare function removeFromMessage(messageId: string, labelName: string, options?: OutputOptions): Promise<LabelActionResult>;
+/**
+ * Create a new label
+ */
+export declare function create(labelName: string, options?: OutputOptions): Promise<LabelActionResult>;
+/**
+ * Delete a label
+ */
+export declare function remove(labelName: string, options?: OutputOptions): Promise<LabelActionResult>;

package/dist/lib/labels.js

@@ -0,0 +1,143 @@
+import { getGmail, output } from './api.js';
+/**
+ * List all labels
+ */
+export async function list(options = {}) {
+    const gmail = await getGmail();
+    const res = await gmail.users.labels.list({
+        userId: 'me'
+    });
+    const labels = (res.data.labels || []).map(label => ({
+        id: label.id,
+        name: label.name,
+        type: label.type || undefined,
+        messageListVisibility: label.messageListVisibility || undefined,
+        labelListVisibility: label.labelListVisibility || undefined
+    }));
+    // Sort: system labels first, then user labels
+    labels.sort((a, b) => {
+        if (a.type === 'system' && b.type !== 'system')
+            return -1;
+        if (a.type !== 'system' && b.type === 'system')
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    output(labels, options);
+    return labels;
+}
+/**
+ * Get label details with counts
+ */
+export async function get(labelId, options = {}) {
+    const gmail = await getGmail();
+    // Resolve label name to ID if needed
+    const resolvedId = await resolveLabelId(gmail, labelId);
+    const res = await gmail.users.labels.get({
+        userId: 'me',
+        id: resolvedId
+    });
+    const label = {
+        id: res.data.id,
+        name: res.data.name,
+        type: res.data.type || undefined,
+        messagesTotal: res.data.messagesTotal || undefined,
+        messagesUnread: res.data.messagesUnread || undefined,
+        threadsTotal: res.data.threadsTotal || undefined,
+        threadsUnread: res.data.threadsUnread || undefined
+    };
+    output(label, options);
+    return label;
+}
+/**
+ * Add label to message
+ */
+export async function addToMessage(messageId, labelName, options = {}) {
+    const gmail = await getGmail();
+    const labelId = await resolveLabelId(gmail, labelName);
+    await gmail.users.messages.modify({
+        userId: 'me',
+        id: messageId,
+        requestBody: {
+            addLabelIds: [labelId]
+        }
+    });
+    const result = { ok: true, messageId, labelAdded: labelName };
+    output(result, options);
+    return result;
+}
+/**
+ * Remove label from message
+ */
+export async function removeFromMessage(messageId, labelName, options = {}) {
+    const gmail = await getGmail();
+    const labelId = await resolveLabelId(gmail, labelName);
+    await gmail.users.messages.modify({
+        userId: 'me',
+        id: messageId,
+        requestBody: {
+            removeLabelIds: [labelId]
+        }
+    });
+    const result = { ok: true, messageId, labelRemoved: labelName };
+    output(result, options);
+    return result;
+}
+/**
+ * Create a new label
+ */
+export async function create(labelName, options = {}) {
+    const gmail = await getGmail();
+    const res = await gmail.users.labels.create({
+        userId: 'me',
+        requestBody: {
+            name: labelName,
+            labelListVisibility: 'labelShow',
+            messageListVisibility: 'show'
+        }
+    });
+    const result = {
+        ok: true,
+        id: res.data.id,
+        name: res.data.name
+    };
+    output(result, options);
+    return result;
+}
+/**
+ * Delete a label
+ */
+export async function remove(labelName, options = {}) {
+    const gmail = await getGmail();
+    const labelId = await resolveLabelId(gmail, labelName);
+    // Don't allow deleting system labels
+    const systemLabels = ['INBOX', 'SENT', 'TRASH', 'SPAM', 'STARRED', 'UNREAD', 'IMPORTANT', 'DRAFT'];
+    if (labelId.startsWith('CATEGORY_') || systemLabels.includes(labelId)) {
+        throw new Error(`Cannot delete system label: ${labelName}`);
+    }
+    await gmail.users.labels.delete({
+        userId: 'me',
+        id: labelId
+    });
+    const result = { ok: true, deleted: labelName };
+    output(result, options);
+    return result;
+}
+/**
+ * Resolve label name to ID
+ */
+async function resolveLabelId(gmail, labelNameOrId) {
+    // Check if already an ID (system labels or Label_xxx format)
+    const systemLabels = ['INBOX', 'SENT', 'TRASH', 'SPAM', 'STARRED', 'UNREAD', 'IMPORTANT', 'DRAFT', 'CHAT'];
+    if (labelNameOrId.startsWith('Label_') ||
+        labelNameOrId.startsWith('CATEGORY_') ||
+        systemLabels.includes(labelNameOrId.toUpperCase())) {
+        return labelNameOrId.toUpperCase();
+    }
+    // Look up by name
+    const res = await gmail.users.labels.list({ userId: 'me' });
+    const label = res.data.labels?.find(l => l.name?.toLowerCase() === labelNameOrId.toLowerCase());
+    if (!label) {
+        throw new Error(`Label not found: ${labelNameOrId}`);
+    }
+    return label.id;
+}

package/dist/lib/messages.d.ts

@@ -0,0 +1,77 @@
+import { type OutputOptions } from './api.js';
+/** Message summary */
+export interface MessageSummary {
+    id: string;
+    threadId?: string;
+    date: string | null;
+    from: string;
+    to: string;
+    subject: string;
+    snippet?: string;
+    labels?: string[];
+    unread?: boolean;
+    starred?: boolean;
+    important?: boolean;
+    body?: string;
+    cc?: string | null;
+}
+/** Action result */
+export interface ActionResult {
+    ok: boolean;
+    archived?: string;
+    trashed?: string;
+    untrashed?: string;
+    starred?: string;
+    unstarred?: string;
+    markedRead?: string;
+    markedUnread?: string;
+}
+/** Message list options */
+export interface MessageListOptions extends OutputOptions {
+    limit?: number;
+    body?: boolean;
+}
+/**
+ * List inbox messages
+ */
+export declare function inbox(options?: MessageListOptions): Promise<MessageSummary[]>;
+/**
+ * List unread messages
+ */
+export declare function unread(options?: MessageListOptions): Promise<MessageSummary[]>;
+/**
+ * Search messages with Gmail query syntax
+ */
+export declare function search(query: string, options?: MessageListOptions): Promise<MessageSummary[]>;
+/**
+ * Read a full message
+ */
+export declare function read(messageId: string, options?: OutputOptions): Promise<MessageSummary>;
+/**
+ * Archive a message (remove from INBOX)
+ */
+export declare function archive(messageId: string, options?: OutputOptions): Promise<ActionResult>;
+/**
+ * Trash a message
+ */
+export declare function trash(messageId: string, options?: OutputOptions): Promise<ActionResult>;
+/**
+ * Untrash a message
+ */
+export declare function untrash(messageId: string, options?: OutputOptions): Promise<ActionResult>;
+/**
+ * Star a message
+ */
+export declare function star(messageId: string, options?: OutputOptions): Promise<ActionResult>;
+/**
+ * Unstar a message
+ */
+export declare function unstar(messageId: string, options?: OutputOptions): Promise<ActionResult>;
+/**
+ * Mark as read
+ */
+export declare function markRead(messageId: string, options?: OutputOptions): Promise<ActionResult>;
+/**
+ * Mark as unread
+ */
+export declare function markUnread(messageId: string, options?: OutputOptions): Promise<ActionResult>;