@divyacon/piece-gmail 0.0.0-stage → 0.1.1

package/src/lib/actions/reply-to-email-action.ts

@@ -0,0 +1,228 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import mime from 'mime-types';
+import MailComposer from 'nodemailer/lib/mail-composer';
+import Mail, { Attachment } from 'nodemailer/lib/mailer';
+import { gmailAuth, createGoogleClient, getUserEmail } from '../auth';
+import { gmail as googleGmail } from '@googleapis/gmail';
+import { GmailProps } from '../common/props';
+import { replyToEmailActionOutputSchema } from '../output-schemas';
+
+export const gmailReplyToEmailAction = createAction({
+  auth: gmailAuth,
+  name: 'reply_to_email',
+  displayName: 'Reply to Email',
+  description: 'Reply to an existing email.',
+  audience: 'human',
+  aiMetadata: {
+    description:
+      'Sends a reply to an existing email, preserving the thread and subject and addressing the original sender (reply) or all participants (reply all). Use this to respond within a known conversation; requires the Gmail message ID of the email being answered. Not idempotent: each call sends a new reply message into the thread.',
+    idempotent: false,
+  },
+  props: {
+    message_id: GmailProps.message,
+    reply_type: Property.StaticDropdown({
+      displayName: 'Reply Type',
+      description:
+        'Choose whether to reply to sender only or to all recipients',
+      required: true,
+      defaultValue: 'reply',
+      options: {
+        disabled: false,
+        options: [
+          {
+            label: 'Reply (to sender only)',
+            value: 'reply',
+          },
+          {
+            label: 'Reply All (to all recipients)',
+            value: 'reply_all',
+          },
+        ],
+      },
+    }),
+    body_type: Property.StaticDropdown({
+      displayName: 'Body Type',
+      required: true,
+      defaultValue: 'plain_text',
+      options: {
+        disabled: false,
+        options: [
+          {
+            label: 'Plain text',
+            value: 'plain_text',
+          },
+          {
+            label: 'HTML',
+            value: 'html',
+          },
+        ],
+      },
+    }),
+    body: Property.LongText({
+      displayName: 'Reply Body',
+      description: 'Your reply message content',
+      required: true,
+    }),
+    sender_name: Property.ShortText({
+      displayName: 'Sender Name',
+      description: 'Optional sender name to display',
+      required: false,
+    }),
+    attachment: Property.File({
+      displayName: 'Attachment',
+      description: 'Optional file to attach to your reply',
+      required: false,
+    }),
+    attachment_name: Property.ShortText({
+      displayName: 'Attachment Name',
+      description: 'Custom name for the attachment',
+      required: false,
+    }),
+  },
+  outputSchema: replyToEmailActionOutputSchema,
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const gmail = googleGmail({ version: 'v1', auth: authClient });
+
+    const originalMessage = await gmail.users.messages.get({
+      userId: 'me',
+      id: context.propsValue.message_id,
+      format: 'full',
+    });
+
+    if (!originalMessage.data || !originalMessage.data.payload) {
+      throw new Error('Could not fetch original message details');
+    }
+
+    const headers = originalMessage.data.payload.headers || [];
+    const headerMap = headers.reduce(
+      (acc: { [key: string]: string }, header) => {
+        if (header.name && header.value) {
+          acc[header.name.toLowerCase()] = header.value;
+        }
+        return acc;
+      },
+      {}
+    );
+
+    const originalSubject = headerMap['subject'] || '';
+    const originalFrom = headerMap['from'] || '';
+    const originalTo = headerMap['to'] || '';
+    const originalCc = headerMap['cc'] || '';
+    const originalReplyTo = headerMap['reply-to'] || '';
+    const originalMessageId = headerMap['message-id'] || '';
+    const originalReferences = headerMap['references'] || '';
+
+    const toRecipients: string[] = [];
+    const ccRecipients: string[] = [];
+
+    if (context.propsValue.reply_type === 'reply_all') {
+      const senderEmail = originalReplyTo || originalFrom;
+      if (senderEmail) {
+        toRecipients.push(senderEmail);
+      }
+
+      const currentUserEmail = await getUserEmail(context.auth, authClient);
+
+      if (originalTo) {
+        const toEmails = originalTo.split(',').map((email) => email.trim());
+        toRecipients.push(
+          ...toEmails.filter((email) => !email.includes(currentUserEmail || ''))
+        );
+      }
+
+      if (originalCc) {
+        const ccEmails = originalCc.split(',').map((email) => email.trim());
+        ccRecipients.push(
+          ...ccEmails.filter((email) => !email.includes(currentUserEmail || ''))
+        );
+      }
+    } else {
+      const senderEmail = originalReplyTo || originalFrom;
+      if (senderEmail) {
+        toRecipients.push(senderEmail);
+      }
+    }
+
+    let replySubject = originalSubject;
+    if (!replySubject.toLowerCase().startsWith('re:')) {
+      replySubject = `Re: ${replySubject}`;
+    }
+
+    let referencesHeader = originalMessageId;
+    if (originalReferences) {
+      referencesHeader = `${originalReferences} ${originalMessageId}`;
+    }
+
+    const senderEmail = await getUserEmail(context.auth, authClient);
+
+    const subjectBase64 = Buffer.from(replySubject).toString('base64');
+    const mailOptions: Mail.Options = {
+      to: toRecipients.join(', '),
+      cc: ccRecipients.length > 0 ? ccRecipients.join(', ') : undefined,
+      subject: `=?UTF-8?B?${subjectBase64}?=`,
+      text:
+        context.propsValue.body_type === 'plain_text'
+          ? context.propsValue.body
+          : undefined,
+      html:
+        context.propsValue.body_type === 'html'
+          ? context.propsValue.body
+          : undefined,
+      attachments: [],
+      headers: [
+        {
+          key: 'In-Reply-To',
+          value: originalMessageId,
+        },
+        {
+          key: 'References',
+          value: referencesHeader,
+        },
+      ],
+    };
+
+    if (senderEmail) {
+      mailOptions.from = context.propsValue.sender_name
+        ? `${context.propsValue.sender_name} <${senderEmail}>`
+        : senderEmail;
+    }
+
+    if (context.propsValue.attachment) {
+      const lookupResult = mime.lookup(
+        context.propsValue.attachment.extension || ''
+      );
+      const attachmentOption: Attachment[] = [
+        {
+          filename:
+            context.propsValue.attachment_name ??
+            context.propsValue.attachment.filename,
+          content: context.propsValue.attachment.base64,
+          contentType: lookupResult || undefined,
+          encoding: 'base64',
+        },
+      ];
+      mailOptions.attachments = attachmentOption;
+    }
+
+    const mail: any = new MailComposer(mailOptions).compile();
+    mail.keepBcc = true;
+    const mailBody = await mail.build();
+
+    const encodedPayload = Buffer.from(mailBody)
+      .toString('base64')
+      .replace(/\+/g, '-')
+      .replace(/\//g, '_');
+
+    const response = await gmail.users.messages.send({
+      userId: 'me',
+      requestBody: {
+        threadId: originalMessage.data.threadId || undefined,
+        raw: encodedPayload,
+      },
+    });
+
+    return response.data;
+  },
+});

package/src/lib/actions/request-approval-in-email.ts

@@ -0,0 +1,197 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  gmailAuth,
+  createGoogleClient,
+  getAccessToken,
+  getUserEmail,
+} from '../auth';
+import { gmail as googleGmail } from '@googleapis/gmail';
+import MailComposer from 'nodemailer/lib/mail-composer';
+import Mail from 'nodemailer/lib/mailer';
+import { assertNotNullOrUndefined } from '@agnocon/pieces-framework';
+import { ExecutionType } from '@agnocon/pieces-framework';
+import { requestApprovalInMailActionOutputSchema } from '../output-schemas';
+
+export const requestApprovalInEmail = createAction({
+  auth: gmailAuth,
+  name: 'request_approval_in_mail',
+  displayName: 'Request Approval in Email',
+  description:
+    'Send approval request email and then wait until the email is approved or disapproved',
+  audience: 'both',
+  aiMetadata: {
+    description:
+      'Sends an email with a single link to a confirmation page where the recipient chooses Approve or Disapprove, then pauses the flow until they respond, resuming with their decision. Use this as a human-in-the-loop gate before proceeding with a sensitive action. The flow blocks indefinitely until a response arrives. Not idempotent: each call sends a new approval email and creates a new wait.',
+    idempotent: false,
+  },
+  props: {
+    receiver: Property.ShortText({
+      displayName: 'Receiver Email (To)',
+      description:
+        'The email address of the recipient who will receive the approval request.',
+      required: true,
+    }),
+
+    cc: Property.Array({
+      displayName: 'CC Email',
+      description:
+        'The email addresses of the recipients who will receive a carbon copy of the approval request.',
+      required: false,
+    }),
+    bcc: Property.Array({
+      displayName: 'BCC Email',
+      description:
+        'The email addresses of the recipients who will receive a blind carbon copy of the approval request.',
+      required: false,
+    }),
+    subject: Property.ShortText({
+      displayName: 'Subject',
+      description: 'The subject of the approval request email.',
+      required: true,
+    }),
+    body: Property.ShortText({
+      displayName: 'Body',
+      description: 'Body for the email you want to send',
+      required: true,
+    }),
+    reply_to: Property.Array({
+      displayName: 'Reply-To Email',
+      description: 'Email address to set as the "Reply-To" header',
+      required: false,
+    }),
+    sender_name: Property.ShortText({
+      displayName: 'Sender Name',
+      required: false,
+    }),
+    from: Property.ShortText({
+      displayName: 'Sender Email',
+      description:
+        "The address must be listed in your GMail account's settings",
+      required: false,
+    }),
+    in_reply_to: Property.ShortText({
+      displayName: 'In reply to',
+      description: 'Reply to this Message-ID',
+      required: false,
+    }),
+  },
+  outputSchema: requestApprovalInMailActionOutputSchema,
+  async run(context) {
+    if (context.executionType === ExecutionType.BEGIN) {
+      try {
+        const token = await getAccessToken(context.auth);
+
+        const { subject, body } = context.propsValue;
+
+        assertNotNullOrUndefined(token, 'token');
+        assertNotNullOrUndefined(context.propsValue.receiver, 'receiver');
+        assertNotNullOrUndefined(subject, 'subject');
+        assertNotNullOrUndefined(body, 'body');
+
+        const waitpoint = await context.run.createWaitpoint({
+          type: 'WEBHOOK',
+        });
+
+        const confirmationLink = `${waitpoint.resumeUrl}/confirm`;
+
+        const htmlBody = `
+        <div>
+          <p>${body}</p>
+          <br />
+          <p>
+            <a href="${confirmationLink}" style="display: inline-block; padding: 10px 20px; background-color: #6e41e2; color: white; text-decoration: none; border-radius: 4px;">Review &amp; Respond</a>
+          </p>
+        </div>
+      `;
+
+        const authClient = await createGoogleClient(context.auth);
+
+        const gmail = googleGmail({ version: 'v1', auth: authClient });
+
+        const subjectBase64 = Buffer.from(
+          context.propsValue['subject']
+        ).toString('base64');
+
+        const replyTo = context.propsValue['reply_to']?.filter(
+          (email) => email !== ''
+        );
+        const receiverEmail = context.propsValue.receiver;
+        const cc = context.propsValue['cc']?.filter((email) => email !== '');
+        const bcc = context.propsValue['bcc']?.filter((email) => email !== '');
+        const mailOptions: Mail.Options = {
+          to: receiverEmail,
+          cc: cc ? cc.join(', ') : undefined,
+          bcc: bcc ? bcc.join(', ') : undefined,
+          subject: `=?UTF-8?B?${subjectBase64}?=`,
+          replyTo: replyTo ? replyTo.join(', ') : '',
+          // text:
+          //   context.propsValue.body_type === 'plain_text'
+          //     ? context.propsValue['body']
+          //     : undefined,
+          html: htmlBody,
+          attachments: [],
+        };
+
+        const senderEmail =
+          context.propsValue.from ||
+          (await getUserEmail(context.auth, authClient));
+        if (senderEmail) {
+          mailOptions.from = context.propsValue.sender_name
+            ? `${context.propsValue['sender_name']} <${senderEmail}>`
+            : senderEmail;
+        }
+        let threadId = undefined;
+        if (context.propsValue.in_reply_to) {
+          mailOptions.headers = [
+            {
+              key: 'References',
+              value: context.propsValue.in_reply_to,
+            },
+            {
+              key: 'In-Reply-To',
+              value: context.propsValue.in_reply_to,
+            },
+          ];
+          const messages = await gmail.users.messages.list({
+            userId: 'me',
+            q: `Rfc822msgid:${context.propsValue.in_reply_to}`,
+          });
+          threadId = messages.data.messages?.[0].threadId;
+        }
+        const mail: any = new MailComposer(mailOptions).compile();
+        mail.keepBcc = true;
+        const mailBody = await mail.build();
+
+        const encodedPayload = Buffer.from(mailBody)
+          .toString('base64')
+          .replace(/\+/g, '-')
+          .replace(/\//g, '_');
+        await gmail.users.messages.send({
+          userId: 'me',
+          requestBody: {
+            threadId,
+            raw: encodedPayload,
+          },
+        });
+        context.run.waitForWaitpoint(waitpoint.id);
+
+        return {
+          approved: false, // default approval is false
+        };
+      } catch (error) {
+        console.error(
+          '[RequestApprovalEmail] Error during BEGIN execution:',
+          error
+        );
+        throw error;
+      }
+    } else {
+      const action = context.resumePayload.queryParams['action'];
+      const approved = action === 'approve';
+
+      return {
+        approved,
+      };
+    }
+  },
+});

package/src/lib/actions/search-email-action.ts

@@ -0,0 +1,219 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { gmailAuth, createGoogleClient } from '../auth';
+import { gmail as googleGmail } from '@googleapis/gmail';
+import { convertAttachment, parseStream } from '../common/data';
+import { GmailProps } from '../common/props';
+import { GmailLabel } from '../common/models';
+import { gmailSearchMailActionOutputSchema } from '../output-schemas';
+
+export const gmailSearchMailAction = createAction({
+  auth: gmailAuth,
+  name: 'gmail_search_mail',
+  displayName: 'Find Email',
+  description:
+    'Find emails using advanced search criteria. If no filters are provided, the latest emails are returned.',
+  audience: 'human',
+  aiMetadata: {
+    description:
+      'Searches the mailbox for emails matching combinable filters (sender, recipient, subject, body text, label, category, date range, attachment presence/name) and returns the matched messages with parsed contents. Use this to locate messages or discover their IDs before reading or replying; with no filters it returns the most recent emails. Bound results with Max Results (1-500, default 10). Idempotent: a read-only search that does not modify the mailbox.',
+    idempotent: true,
+  },
+  props: {
+    from: GmailProps.from,
+    to: GmailProps.to,
+    subject: GmailProps.subject,
+    content: Property.ShortText({
+      displayName: 'Email Content',
+      description: 'Search for specific text within email body',
+      required: false,
+    }),
+    has_attachment: Property.Checkbox({
+      displayName: 'Has Attachment',
+      description: 'Only find emails with attachments',
+      required: false,
+      defaultValue: false,
+    }),
+    attachment_name: Property.ShortText({
+      displayName: 'Attachment Name',
+      description: 'Search for emails with specific attachment filename',
+      required: false,
+    }),
+    label: GmailProps.label({ required: false }),
+    category: GmailProps.category,
+    after_date: Property.DateTime({
+      displayName: 'After Date',
+      description: 'Find emails sent after this date',
+      required: false,
+    }),
+    before_date: Property.DateTime({
+      displayName: 'Before Date',
+      description: 'Find emails sent before this date',
+      required: false,
+    }),
+
+    include_spam_trash: Property.Checkbox({
+      displayName: 'Include Spam & Trash',
+      description:
+        'Include emails from Spam and Trash folders in search results',
+      required: false,
+      defaultValue: false,
+    }),
+    max_results: Property.Number({
+      displayName: 'Max Results',
+      description: 'Maximum number of emails to return (1-500)',
+      required: false,
+      defaultValue: 10,
+    }),
+  },
+  outputSchema: gmailSearchMailActionOutputSchema,
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const gmail = googleGmail({ version: 'v1', auth: authClient });
+
+    const queryParts: string[] = [];
+
+    if (context.propsValue.from?.trim()) {
+      queryParts.push(`from:(${context.propsValue.from.trim()})`);
+    }
+    if (context.propsValue.to?.trim()) {
+      queryParts.push(`to:(${context.propsValue.to.trim()})`);
+    }
+    if (context.propsValue.subject?.trim()) {
+      queryParts.push(`subject:(${context.propsValue.subject.trim()})`);
+    }
+    if (context.propsValue.content?.trim()) {
+      queryParts.push(`"${context.propsValue.content.trim()}"`);
+    }
+
+    if (context.propsValue.has_attachment) {
+      queryParts.push('has:attachment');
+    }
+    if (context.propsValue.attachment_name?.trim()) {
+      queryParts.push(
+        `filename:(${context.propsValue.attachment_name.trim()})`
+      );
+    }
+
+    if (context.propsValue.label) {
+      const label = context.propsValue.label as GmailLabel;
+      queryParts.push(`label:${label.name}`);
+    }
+    if (context.propsValue.category?.trim()) {
+      queryParts.push(`category:${context.propsValue.category.trim()}`);
+    }
+
+    if (context.propsValue.after_date) {
+      const afterDate = new Date(context.propsValue.after_date);
+      const afterDateStr = afterDate
+        .toISOString()
+        .split('T')[0]
+        .replace(/-/g, '/');
+      queryParts.push(`after:${afterDateStr}`);
+    }
+    if (context.propsValue.before_date) {
+      const beforeDate = new Date(context.propsValue.before_date);
+      const beforeDateStr = beforeDate
+        .toISOString()
+        .split('T')[0]
+        .replace(/-/g, '/');
+      queryParts.push(`before:${beforeDateStr}`);
+    }
+
+    const searchQuery = queryParts.join(' ');
+
+    const maxResults = Math.min(
+      Math.max(context.propsValue.max_results || 10, 1),
+      500
+    );
+
+    try {
+      const searchResponse = await gmail.users.messages.list({
+        userId: 'me',
+        ...(searchQuery.trim() ? { q: searchQuery } : {}),
+        maxResults: maxResults,
+        includeSpamTrash: context.propsValue.include_spam_trash,
+      });
+
+      const messages = searchResponse.data.messages || [];
+
+      if (messages.length === 0) {
+        return {
+          found: false,
+          results: {
+            messages: [],
+            count: 0,
+          },
+        };
+      }
+
+      const detailedMessages = await Promise.all(
+        messages.map(async (message) => {
+          try {
+            const rawMailResponse = await gmail.users.messages.get({
+              userId: 'me',
+              id: message.id!,
+              format: 'raw',
+            });
+
+            const parsedMailResponse = await parseStream(
+              Buffer.from(
+                rawMailResponse.data.raw as string,
+                'base64'
+              ).toString('utf-8')
+            );
+
+            return {
+              id: message.id,
+              ...parsedMailResponse,
+              attachments: await convertAttachment(
+                parsedMailResponse.attachments,
+                context.files
+              ),
+            };
+          } catch (error) {
+            console.error(
+              `Failed to get details for message ${message.id}:`,
+              error
+            );
+            return {
+              id: message.id,
+              threadId: message.threadId,
+              error: 'Failed to retrieve message details',
+            };
+          }
+        })
+      );
+
+      return {
+        found: true,
+        results: {
+          messages: detailedMessages,
+          count: detailedMessages.length,
+        },
+      };
+    } catch (error: any) {
+      // Enhanced error handling
+      if (error.code === 400) {
+        if (error.message?.includes('Invalid query')) {
+          throw new Error(
+            `Invalid search query: "${searchQuery}". Please check your search syntax.`
+          );
+        }
+        throw new Error(`Invalid search request: ${error.message}`);
+      } else if (error.code === 403) {
+        throw new Error(
+          'Insufficient permissions to search emails. Ensure the gmail.readonly scope is granted.'
+        );
+      } else if (error.code === 429) {
+        throw new Error(
+          'Gmail API rate limit exceeded. Please try again later.'
+        );
+      } else if (error.code === 500) {
+        throw new Error('Gmail API server error. Please try again later.');
+      }
+
+      throw new Error(`Failed to search emails: ${error.message}`);
+    }
+  },
+});

package/src/lib/actions/send-draft-action.ts

@@ -0,0 +1,54 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { gmailAuth, createGoogleClient } from '../auth';
+import { gmail as googleGmail } from '@googleapis/gmail';
+import { gmailSendDraftActionOutputSchema } from '../output-schemas';
+
+export const gmailSendDraftAction = createAction({
+  auth: gmailAuth,
+  name: 'gmail_send_draft',
+  displayName: 'Send Draft',
+  description: 'Send an existing draft email by its ID.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Sends an existing draft email identified by its draft ID, delivering it to its recipients. Use this after creating or editing a draft with Create Draft / Update Draft; obtain the draft ID from List Drafts. Not idempotent: each call sends the draft as a message.',
+    idempotent: false,
+  },
+  props: {
+    draft_id: Property.ShortText({
+      displayName: 'Draft ID',
+      description: 'The ID of the draft to send (obtain from List Drafts).',
+      required: true,
+    }),
+  },
+  outputSchema: gmailSendDraftActionOutputSchema,
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+    const gmail = googleGmail({ version: 'v1', auth: authClient });
+
+    try {
+      const response = await gmail.users.drafts.send({
+        userId: 'me',
+        requestBody: {
+          id: context.propsValue.draft_id,
+        },
+      });
+      return response.data;
+    } catch (error: any) {
+      if (error.code === 403) {
+        throw new Error(
+          'Insufficient permissions to send a draft. Ensure the gmail.send scope is granted.'
+        );
+      } else if (error.code === 404) {
+        throw new Error(
+          `Draft not found: "${context.propsValue.draft_id}". Use List Drafts to find a valid draft ID.`
+        );
+      } else if (error.code === 429) {
+        throw new Error(
+          'Gmail API rate limit exceeded. Please try again later.'
+        );
+      }
+      throw new Error(`Failed to send draft: ${error.message}`);
+    }
+  },
+});