veryfront 0.0.45 → 0.0.46

package/dist/integrations/gmail/files/ai/tools/search-emails.ts

@@ -0,0 +1,92 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createGmailClient, parseEmailHeaders } from "../../lib/gmail-client.ts";
+
+export default tool({
+  id: "search-emails",
+  description:
+    "Search emails using Gmail's search syntax. Supports queries like 'from:person@email.com', 'subject:meeting', 'after:2024/01/01', etc.",
+  inputSchema: z.object({
+    query: z
+      .string()
+      .min(1)
+      .describe(
+        "Search query using Gmail search syntax (e.g., 'from:boss@company.com subject:urgent')",
+      ),
+    maxResults: z
+      .number()
+      .min(1)
+      .max(50)
+      .default(10)
+      .describe("Maximum number of results to return"),
+  }),
+  execute: async ({ query, maxResults }, context) => {
+    const userId = context?.userId as string | undefined;
+    if (!userId) {
+      return {
+        error: "User not authenticated. Please log in first.",
+      };
+    }
+
+    try {
+      const gmail = createGmailClient(userId);
+
+      const list = await gmail.listMessages({
+        query,
+        maxResults,
+      });
+
+      if (!list.messages || list.messages.length === 0) {
+        return {
+          emails: [],
+          query,
+          message: `No emails found matching: "${query}"`,
+          searchTips: [
+            "from:email@example.com - Search by sender",
+            "to:email@example.com - Search by recipient",
+            "subject:keywords - Search in subject",
+            "after:YYYY/MM/DD - Emails after date",
+            "before:YYYY/MM/DD - Emails before date",
+            "is:unread - Unread emails only",
+            "has:attachment - Emails with attachments",
+          ],
+        };
+      }
+
+      // Fetch metadata for each email
+      const emails = await Promise.all(
+        list.messages.map(async (m: { id: string }) => {
+          const message = await gmail.getMessage(m.id, "metadata");
+          const headers = parseEmailHeaders(message.payload?.headers || []);
+
+          return {
+            id: message.id,
+            threadId: message.threadId,
+            from: headers.from,
+            to: headers.to,
+            subject: headers.subject,
+            date: headers.date,
+            snippet: message.snippet,
+            isUnread: message.labelIds?.includes("UNREAD") || false,
+            labels: message.labelIds,
+          };
+        }),
+      );
+
+      return {
+        emails,
+        query,
+        count: emails.length,
+        message: `Found ${emails.length} email(s) matching: "${query}"`,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Gmail not connected. Please connect your Gmail account.",
+          connectUrl: "/api/auth/gmail",
+        };
+      }
+      throw error;
+    }
+  },
+});

package/dist/integrations/gmail/files/ai/tools/send-email.ts

@@ -0,0 +1,77 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createGmailClient } from "../../lib/gmail-client.ts";
+
+export default tool({
+  id: "send-email",
+  description: "Send an email via Gmail. Can send to multiple recipients with CC and BCC support.",
+  inputSchema: z.object({
+    to: z
+      .union([z.string().email(), z.array(z.string().email())])
+      .describe("Email recipient(s)"),
+    subject: z
+      .string()
+      .min(1)
+      .describe("Email subject line"),
+    body: z
+      .string()
+      .min(1)
+      .describe("Email body content"),
+    cc: z
+      .union([z.string().email(), z.array(z.string().email())])
+      .optional()
+      .describe("CC recipient(s)"),
+    bcc: z
+      .union([z.string().email(), z.array(z.string().email())])
+      .optional()
+      .describe("BCC recipient(s)"),
+    isHtml: z
+      .boolean()
+      .default(false)
+      .describe("Whether the body contains HTML"),
+  }),
+  execute: async ({ to, subject, body, cc, bcc, isHtml }, context) => {
+    const userId = context?.userId as string | undefined;
+    if (!userId) {
+      return {
+        error: "User not authenticated. Please log in first.",
+      };
+    }
+
+    try {
+      const gmail = createGmailClient(userId);
+
+      const result = await gmail.sendEmail({
+        to,
+        subject,
+        body,
+        cc,
+        bcc,
+        isHtml,
+      });
+
+      const recipients = Array.isArray(to) ? to.join(", ") : to;
+
+      return {
+        success: true,
+        messageId: result.id,
+        threadId: result.threadId,
+        message: `Email sent successfully to ${recipients}.`,
+        details: {
+          to: recipients,
+          subject,
+          cc: cc ? (Array.isArray(cc) ? cc.join(", ") : cc) : undefined,
+          bcc: bcc ? (Array.isArray(bcc) ? bcc.join(", ") : bcc) : undefined,
+        },
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Gmail not connected. Please connect your Gmail account.",
+          connectUrl: "/api/auth/gmail",
+        };
+      }
+      throw error;
+    }
+  },
+});

package/dist/integrations/gmail/files/app/api/auth/gmail/callback/route.ts

@@ -0,0 +1,114 @@
+/**
+ * Gmail OAuth Callback
+ *
+ * Handles the OAuth callback from Google, exchanges code for tokens,
+ * and stores them securely.
+ */
+
+import { exchangeCodeForTokens } from "../../../../../lib/oauth.ts";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+import { gmailOAuthProvider } from "../../../../../lib/gmail-client.ts";
+
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const error = url.searchParams.get("error");
+
+  // Handle OAuth errors
+  if (error) {
+    const errorDescription = url.searchParams.get("error_description") || error;
+    return new Response(
+      `
+      <html>
+        <head><title>Connection Failed</title></head>
+        <body style="font-family: system-ui; padding: 40px; text-align: center;">
+          <h1>Gmail Connection Failed</h1>
+          <p style="color: #666;">${errorDescription}</p>
+          <a href="/" style="color: #0066cc;">Return to App</a>
+        </body>
+      </html>
+      `,
+      {
+        status: 400,
+        headers: { "Content-Type": "text/html" },
+      },
+    );
+  }
+
+  if (!code || !state) {
+    return new Response("Missing code or state parameter", { status: 400 });
+  }
+
+  // Validate state from cookie
+  const cookies = req.headers.get("cookie") || "";
+  const stateCookie = cookies
+    .split(";")
+    .find((c) => c.trim().startsWith("gmail_oauth_state="));
+  const savedState = stateCookie?.split("=")[1]?.trim();
+
+  if (state !== savedState) {
+    return new Response("Invalid state parameter", { status: 400 });
+  }
+
+  try {
+    const origin = url.origin;
+    const redirectUri = `${origin}${gmailOAuthProvider.callbackPath}`;
+
+    // Exchange code for tokens
+    const tokens = await exchangeCodeForTokens(
+      gmailOAuthProvider,
+      code,
+      redirectUri,
+    );
+
+    // Get actual user ID from session in production
+    const userId = "current-user";
+
+    // Store tokens
+    await tokenStore.setToken(userId, "gmail", tokens);
+
+    // Clear state cookie and redirect to success page
+    return new Response(
+      `
+      <html>
+        <head>
+          <title>Gmail Connected</title>
+          <meta http-equiv="refresh" content="2;url=/" />
+        </head>
+        <body style="font-family: system-ui; padding: 40px; text-align: center;">
+          <h1 style="color: #22c55e;">✓ Gmail Connected!</h1>
+          <p style="color: #666;">Your Gmail account has been connected successfully.</p>
+          <p style="color: #999; font-size: 14px;">Redirecting...</p>
+          <a href="/" style="color: #0066cc;">Return to App</a>
+        </body>
+      </html>
+      `,
+      {
+        status: 200,
+        headers: {
+          "Content-Type": "text/html",
+          "Set-Cookie": "gmail_oauth_state=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
+        },
+      },
+    );
+  } catch (err) {
+    console.error("Gmail OAuth error:", err);
+    return new Response(
+      `
+      <html>
+        <head><title>Connection Failed</title></head>
+        <body style="font-family: system-ui; padding: 40px; text-align: center;">
+          <h1>Gmail Connection Failed</h1>
+          <p style="color: #666;">Unable to complete Gmail authorization. Please try again.</p>
+          <a href="/api/auth/gmail" style="color: #0066cc;">Try Again</a>
+        </body>
+      </html>
+      `,
+      {
+        status: 500,
+        headers: { "Content-Type": "text/html" },
+      },
+    );
+  }
+}

package/dist/integrations/gmail/files/app/api/auth/gmail/route.ts

@@ -0,0 +1,29 @@
+/**
+ * Gmail OAuth Initiation
+ *
+ * Redirects to Google OAuth consent screen
+ */
+
+import { getAuthorizationUrl } from "../../../../lib/oauth.ts";
+import { gmailOAuthProvider } from "../../../../lib/gmail-client.ts";
+
+export function GET(req: Request) {
+  const url = new URL(req.url);
+  const origin = url.origin;
+
+  // Generate a random state for CSRF protection
+  const state = crypto.randomUUID();
+
+  // Store state in a cookie for validation
+  const redirectUri = `${origin}${gmailOAuthProvider.callbackPath}`;
+  const authUrl = getAuthorizationUrl(gmailOAuthProvider, state, redirectUri);
+
+  // Set state cookie and redirect to Google
+  return new Response(null, {
+    status: 302,
+    headers: {
+      Location: authUrl,
+      "Set-Cookie": `gmail_oauth_state=${state}; Path=/; HttpOnly; SameSite=Lax; Max-Age=600`,
+    },
+  });
+}

package/dist/integrations/gmail/files/lib/gmail-client.ts

@@ -0,0 +1,259 @@
+/**
+ * Gmail API Client
+ *
+ * Provides a type-safe interface to Gmail API operations.
+ */
+
+import { tokenStore as _tokenStore } from "./token-store.ts";
+import { getValidToken } from "./oauth.ts";
+
+// Helper for Cross-Platform environment access
+function getEnv(key: string): string | undefined {
+  // @ts-ignore - Deno global
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore - Deno global
+    return Deno.env.get(key);
+  } // @ts-ignore - process global
+  else if (typeof process !== "undefined" && process.env) {
+    // @ts-ignore - process global
+    return process.env[key];
+  }
+  return undefined;
+}
+
+const GMAIL_API_BASE = "https://gmail.googleapis.com/gmail/v1";
+
+export interface GmailMessage {
+  id: string;
+  threadId: string;
+  labelIds: string[];
+  snippet: string;
+  payload?: {
+    headers: Array<{ name: string; value: string }>;
+    body?: { data?: string; size: number };
+    parts?: Array<{
+      mimeType: string;
+      body?: { data?: string; size: number };
+    }>;
+  };
+  internalDate: string;
+}
+
+export interface GmailMessageList {
+  messages: Array<{ id: string; threadId: string }>;
+  nextPageToken?: string;
+  resultSizeEstimate: number;
+}
+
+export interface SendEmailOptions {
+  to: string | string[];
+  subject: string;
+  body: string;
+  cc?: string | string[];
+  bcc?: string | string[];
+  replyTo?: string;
+  isHtml?: boolean;
+}
+
+/**
+ * Gmail OAuth provider configuration
+ */
+export const gmailOAuthProvider = {
+  name: "gmail",
+  authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+  tokenUrl: "https://oauth2.googleapis.com/token",
+  clientId: getEnv("GOOGLE_CLIENT_ID") || "",
+  clientSecret: getEnv("GOOGLE_CLIENT_SECRET") || "",
+  scopes: [
+    "https://www.googleapis.com/auth/gmail.readonly",
+    "https://www.googleapis.com/auth/gmail.send",
+    "https://www.googleapis.com/auth/gmail.modify",
+  ],
+  callbackPath: "/api/auth/gmail/callback",
+};
+
+/**
+ * Create a Gmail client for a specific user
+ */
+export function createGmailClient(userId: string) {
+  async function getAccessToken(): Promise<string> {
+    const token = await getValidToken(gmailOAuthProvider, userId, "gmail");
+    if (!token) {
+      throw new Error("Gmail not connected. Please connect your Gmail account first.");
+    }
+    return token;
+  }
+
+  async function apiRequest<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    const accessToken = await getAccessToken();
+
+    const response = await fetch(`${GMAIL_API_BASE}${endpoint}`, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Gmail API error: ${response.status} - ${error}`);
+    }
+
+    return response.json();
+  }
+
+  return {
+    /**
+     * List messages from the user's mailbox
+     */
+    listMessages(options: {
+      maxResults?: number;
+      query?: string;
+      labelIds?: string[];
+      pageToken?: string;
+    } = {}): Promise<GmailMessageList> {
+      const params = new URLSearchParams();
+      if (options.maxResults) params.set("maxResults", String(options.maxResults));
+      if (options.query) params.set("q", options.query);
+      if (options.labelIds) params.set("labelIds", options.labelIds.join(","));
+      if (options.pageToken) params.set("pageToken", options.pageToken);
+
+      const query = params.toString();
+      return apiRequest<GmailMessageList>(
+        `/users/me/messages${query ? `?${query}` : ""}`,
+      );
+    },
+
+    /**
+     * Get a specific message by ID
+     */
+    getMessage(
+      messageId: string,
+      format: "full" | "metadata" | "minimal" = "full",
+    ): Promise<GmailMessage> {
+      return apiRequest<GmailMessage>(
+        `/users/me/messages/${messageId}?format=${format}`,
+      );
+    },
+
+    /**
+     * Send an email
+     */
+    sendEmail(options: SendEmailOptions): Promise<{ id: string; threadId: string }> {
+      const toAddresses = Array.isArray(options.to) ? options.to.join(", ") : options.to;
+      const ccAddresses = options.cc
+        ? Array.isArray(options.cc) ? options.cc.join(", ") : options.cc
+        : "";
+      const bccAddresses = options.bcc
+        ? Array.isArray(options.bcc) ? options.bcc.join(", ") : options.bcc
+        : "";
+
+      const headers = [
+        `To: ${toAddresses}`,
+        `Subject: ${options.subject}`,
+        options.isHtml
+          ? "Content-Type: text/html; charset=utf-8"
+          : "Content-Type: text/plain; charset=utf-8",
+      ];
+
+      if (ccAddresses) headers.push(`Cc: ${ccAddresses}`);
+      if (bccAddresses) headers.push(`Bcc: ${bccAddresses}`);
+      if (options.replyTo) headers.push(`Reply-To: ${options.replyTo}`);
+
+      const email = `${headers.join("\r\n")}\r\n\r\n${options.body}`;
+
+      // Encode email as base64url
+      const encodedEmail = btoa(email)
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+
+      return apiRequest<{ id: string; threadId: string }>("/users/me/messages/send", {
+        method: "POST",
+        body: JSON.stringify({ raw: encodedEmail }),
+      });
+    },
+
+    /**
+     * Search emails by query
+     */
+    async searchEmails(query: string, maxResults = 10): Promise<GmailMessage[]> {
+      const list = await this.listMessages({ query, maxResults });
+
+      if (!list.messages || list.messages.length === 0) {
+        return [];
+      }
+
+      // Fetch full message details
+      const messages = await Promise.all(
+        list.messages.map((m) => this.getMessage(m.id, "metadata")),
+      );
+
+      return messages;
+    },
+
+    /**
+     * Get unread emails
+     */
+    getUnreadEmails(maxResults = 10): Promise<GmailMessage[]> {
+      return this.searchEmails("is:unread", maxResults);
+    },
+
+    /**
+     * Mark email as read
+     */
+    async markAsRead(messageId: string): Promise<void> {
+      await apiRequest(`/users/me/messages/${messageId}/modify`, {
+        method: "POST",
+        body: JSON.stringify({
+          removeLabelIds: ["UNREAD"],
+        }),
+      });
+    },
+
+    /**
+     * Archive an email
+     */
+    async archiveEmail(messageId: string): Promise<void> {
+      await apiRequest(`/users/me/messages/${messageId}/modify`, {
+        method: "POST",
+        body: JSON.stringify({
+          removeLabelIds: ["INBOX"],
+        }),
+      });
+    },
+  };
+}
+
+/**
+ * Parse email headers to extract common fields
+ */
+export function parseEmailHeaders(
+  headers: Array<{ name: string; value: string }>,
+): {
+  from: string;
+  to: string;
+  subject: string;
+  date: string;
+} {
+  const getHeader = (name: string): string => {
+    const header = headers.find(
+      (h) => h.name.toLowerCase() === name.toLowerCase(),
+    );
+    return header?.value || "";
+  };
+
+  return {
+    from: getHeader("From"),
+    to: getHeader("To"),
+    subject: getHeader("Subject"),
+    date: getHeader("Date"),
+  };
+}
+
+export type GmailClient = ReturnType<typeof createGmailClient>;