veryfront 0.0.45 → 0.0.47

package/dist/integrations/_base/files/lib/oauth.ts

@@ -0,0 +1,145 @@
+/**
+ * OAuth Helper Functions
+ *
+ * Provides utilities for OAuth 2.0 authorization flows.
+ */
+
+import { type OAuthToken, tokenStore } from "./token-store.ts";
+
+export interface OAuthProvider {
+  name: string;
+  authorizationUrl: string;
+  tokenUrl: string;
+  clientId: string;
+  clientSecret: string;
+  scopes: string[];
+  callbackPath: string;
+}
+
+/**
+ * Generate OAuth authorization URL
+ */
+export function getAuthorizationUrl(
+  provider: OAuthProvider,
+  state: string,
+  redirectUri: string,
+): string {
+  const params = new URLSearchParams({
+    client_id: provider.clientId,
+    redirect_uri: redirectUri,
+    response_type: "code",
+    scope: provider.scopes.join(" "),
+    state,
+    access_type: "offline",
+    prompt: "consent",
+  });
+
+  return `${provider.authorizationUrl}?${params.toString()}`;
+}
+
+/**
+ * Exchange authorization code for tokens
+ */
+export async function exchangeCodeForTokens(
+  provider: OAuthProvider,
+  code: string,
+  redirectUri: string,
+): Promise<OAuthToken> {
+  const response = await fetch(provider.tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: new URLSearchParams({
+      client_id: provider.clientId,
+      client_secret: provider.clientSecret,
+      code,
+      grant_type: "authorization_code",
+      redirect_uri: redirectUri,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token exchange failed: ${response.status} - ${error}`);
+  }
+
+  const data = await response.json();
+
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: data.expires_in ? Date.now() + (data.expires_in * 1000) : undefined,
+    tokenType: data.token_type || "Bearer",
+    scope: data.scope,
+  };
+}
+
+/**
+ * Refresh an expired access token
+ */
+export async function refreshAccessToken(
+  provider: OAuthProvider,
+  refreshToken: string,
+): Promise<OAuthToken> {
+  const response = await fetch(provider.tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: new URLSearchParams({
+      client_id: provider.clientId,
+      client_secret: provider.clientSecret,
+      refresh_token: refreshToken,
+      grant_type: "refresh_token",
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token refresh failed: ${response.status} - ${error}`);
+  }
+
+  const data = await response.json();
+
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token || refreshToken,
+    expiresAt: data.expires_in ? Date.now() + (data.expires_in * 1000) : undefined,
+    tokenType: data.token_type || "Bearer",
+    scope: data.scope,
+  };
+}
+
+/**
+ * Get a valid access token, refreshing if necessary
+ */
+export async function getValidToken(
+  provider: OAuthProvider,
+  userId: string,
+  service: string,
+): Promise<string | null> {
+  const token = await tokenStore.getToken(userId, service);
+
+  if (!token) {
+    return null;
+  }
+
+  // Check if token is expired (with 5 minute buffer)
+  // If no expiresAt, token doesn't expire (e.g., GitHub)
+  const isExpired = token.expiresAt ? token.expiresAt < Date.now() + 5 * 60 * 1000 : false;
+
+  if (isExpired && token.refreshToken) {
+    try {
+      const newToken = await refreshAccessToken(provider, token.refreshToken);
+      await tokenStore.setToken(userId, service, newToken);
+      return newToken.accessToken;
+    } catch {
+      // Refresh failed, user needs to re-authorize
+      await tokenStore.revokeToken(userId, service);
+      return null;
+    }
+  }
+
+  return token.accessToken;
+}

package/dist/integrations/_base/files/lib/token-store.ts

@@ -0,0 +1,109 @@
+/**
+ * OAuth Token Store
+ *
+ * Simple in-memory token store for development.
+ * Replace with a database or KV store for production.
+ */
+
+export interface OAuthToken {
+  accessToken: string;
+  refreshToken?: string;
+  expiresAt?: number;
+  tokenType?: string;
+  scope?: string;
+}
+
+export interface TokenStore {
+  getToken(userId: string, service: string): Promise<OAuthToken | null>;
+  setToken(userId: string, service: string, token: OAuthToken): Promise<void>;
+  revokeToken(userId: string, service: string): Promise<void>;
+  isConnected(userId: string, service: string): Promise<boolean>;
+}
+
+// In-memory storage for development
+const tokens = new Map<string, OAuthToken>();
+
+function getKey(userId: string, service: string): string {
+  return `${userId}:${service}`;
+}
+
+/**
+ * Simple in-memory token store
+ *
+ * NOTE: This is for development only. In production, use:
+ * - Database (Postgres, SQLite, etc.)
+ * - KV store (Cloudflare Workers KV, Vercel KV, etc.)
+ * - Encrypted file storage
+ */
+export const tokenStore: TokenStore = {
+  getToken(userId: string, service: string): Promise<OAuthToken | null> {
+    const key = getKey(userId, service);
+    return Promise.resolve(tokens.get(key) || null);
+  },
+
+  setToken(
+    userId: string,
+    service: string,
+    token: OAuthToken,
+  ): Promise<void> {
+    const key = getKey(userId, service);
+    tokens.set(key, token);
+    return Promise.resolve();
+  },
+
+  revokeToken(userId: string, service: string): Promise<void> {
+    const key = getKey(userId, service);
+    tokens.delete(key);
+    return Promise.resolve();
+  },
+
+  async isConnected(userId: string, service: string): Promise<boolean> {
+    const token = await this.getToken(userId, service);
+    if (!token) return false;
+    // Check if token is not expired (if no expiry, token doesn't expire)
+    return !token.expiresAt || token.expiresAt > Date.now();
+  },
+};
+
+/**
+ * Factory function to create a custom token store
+ */
+export function createTokenStore(options: {
+  get: (key: string) => Promise<string | null>;
+  set: (key: string, value: string) => Promise<void>;
+  delete: (key: string) => Promise<void>;
+}): TokenStore {
+  return {
+    async getToken(userId: string, service: string): Promise<OAuthToken | null> {
+      const key = getKey(userId, service);
+      const data = await options.get(key);
+      if (!data) return null;
+      try {
+        return JSON.parse(data) as OAuthToken;
+      } catch {
+        return null;
+      }
+    },
+
+    async setToken(
+      userId: string,
+      service: string,
+      token: OAuthToken,
+    ): Promise<void> {
+      const key = getKey(userId, service);
+      await options.set(key, JSON.stringify(token));
+    },
+
+    async revokeToken(userId: string, service: string): Promise<void> {
+      const key = getKey(userId, service);
+      await options.delete(key);
+    },
+
+    async isConnected(userId: string, service: string): Promise<boolean> {
+      const token = await this.getToken(userId, service);
+      if (!token) return false;
+      // Check if token is not expired (if no expiry, token doesn't expire)
+      return !token.expiresAt || token.expiresAt > Date.now();
+    },
+  };
+}

package/dist/integrations/calendar/connector.json

@@ -0,0 +1,77 @@
+{
+  "name": "calendar",
+  "displayName": "Google Calendar",
+  "icon": "calendar.svg",
+  "description": "Manage events, find free time, and schedule meetings",
+  "auth": {
+    "type": "oauth2",
+    "provider": "google",
+    "authorizationUrl": "https://accounts.google.com/o/oauth2/v2/auth",
+    "tokenUrl": "https://oauth2.googleapis.com/token",
+    "scopes": [
+      "https://www.googleapis.com/auth/calendar.readonly",
+      "https://www.googleapis.com/auth/calendar.events"
+    ],
+    "callbackPath": "/api/auth/calendar/callback"
+  },
+  "envVars": [
+    {
+      "name": "GOOGLE_CLIENT_ID",
+      "description": "Google OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://console.cloud.google.com/apis/credentials"
+    },
+    {
+      "name": "GOOGLE_CLIENT_SECRET",
+      "description": "Google OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://console.cloud.google.com/apis/credentials"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-events",
+      "name": "List Events",
+      "description": "Get upcoming calendar events",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-event",
+      "name": "Create Event",
+      "description": "Schedule a new calendar event",
+      "requiresWrite": true
+    },
+    {
+      "id": "find-free-time",
+      "name": "Find Free Time",
+      "description": "Find available time slots in calendar",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "block-deep-work",
+      "title": "Block time for deep work",
+      "prompt": "Find a 2-hour block for focused work this week and add it to my calendar.",
+      "category": "productivity",
+      "icon": "clock"
+    },
+    {
+      "id": "schedule-meeting",
+      "title": "Schedule a meeting",
+      "prompt": "Help me schedule a meeting. Find available time slots and create the calendar event.",
+      "category": "productivity",
+      "icon": "users"
+    },
+    {
+      "id": "today-agenda",
+      "title": "What's on my calendar today?",
+      "prompt": "Show me my calendar for today and summarize my schedule.",
+      "category": "productivity",
+      "icon": "calendar"
+    }
+  ],
+  "suggestedWith": ["gmail", "slack"]
+}

package/dist/integrations/calendar/files/ai/tools/create-event.ts

@@ -0,0 +1,83 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createCalendarClient } from "../../lib/calendar-client.ts";
+
+export default tool({
+  id: "create-event",
+  description: "Create a new event in Google Calendar",
+  inputSchema: z.object({
+    title: z
+      .string()
+      .min(1)
+      .describe("Event title"),
+    startTime: z
+      .string()
+      .describe("Start time in ISO 8601 format (e.g., '2024-01-15T09:00:00')"),
+    endTime: z
+      .string()
+      .describe("End time in ISO 8601 format (e.g., '2024-01-15T10:00:00')"),
+    description: z
+      .string()
+      .optional()
+      .describe("Event description"),
+    location: z
+      .string()
+      .optional()
+      .describe("Event location"),
+    attendees: z
+      .array(z.string().email())
+      .optional()
+      .describe("Email addresses of attendees to invite"),
+    timeZone: z
+      .string()
+      .default("UTC")
+      .describe("Time zone for the event (e.g., 'America/New_York')"),
+  }),
+  execute: async (
+    { title, startTime, endTime, description, location, attendees, timeZone },
+    context,
+  ) => {
+    const userId = context?.userId as string | undefined;
+    if (!userId) {
+      return {
+        error: "User not authenticated. Please log in first.",
+      };
+    }
+
+    try {
+      const calendar = createCalendarClient(userId);
+
+      const event = await calendar.createEvent({
+        summary: title,
+        start: startTime,
+        end: endTime,
+        description,
+        location,
+        attendees,
+        timeZone,
+      });
+
+      return {
+        success: true,
+        event: {
+          id: event.id,
+          title: event.summary,
+          start: event.start.dateTime || event.start.date,
+          end: event.end.dateTime || event.end.date,
+          url: event.htmlLink,
+          location: event.location,
+          attendees: event.attendees?.map((a: { email: string }) => a.email) || [],
+        },
+        message: `Event "${title}" created successfully.`,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Calendar not connected. Please connect your Google Calendar.",
+          connectUrl: "/api/auth/calendar",
+        };
+      }
+      throw error;
+    }
+  },
+});

package/dist/integrations/calendar/files/ai/tools/find-free-time.ts

@@ -0,0 +1,108 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createCalendarClient } from "../../lib/calendar-client.ts";
+
+export default tool({
+  id: "find-free-time",
+  description: "Find available time slots in the calendar for scheduling",
+  inputSchema: z.object({
+    durationMinutes: z
+      .number()
+      .min(15)
+      .max(480)
+      .default(60)
+      .describe("Duration needed in minutes"),
+    daysToSearch: z
+      .number()
+      .min(1)
+      .max(14)
+      .default(7)
+      .describe("Number of days to search ahead"),
+    workingHoursOnly: z
+      .boolean()
+      .default(true)
+      .describe("Only show slots during working hours (9 AM - 6 PM)"),
+  }),
+  execute: async ({ durationMinutes, daysToSearch, workingHoursOnly }, context) => {
+    const userId = context?.userId as string | undefined;
+    if (!userId) {
+      return {
+        error: "User not authenticated. Please log in first.",
+      };
+    }
+
+    try {
+      const calendar = createCalendarClient(userId);
+
+      const now = new Date();
+      const searchEnd = new Date();
+      searchEnd.setDate(searchEnd.getDate() + (daysToSearch ?? 7));
+
+      type FreeSlot = { start: Date; end: Date };
+      const freeSlots = (await calendar.findFreeSlots({
+        timeMin: now,
+        timeMax: searchEnd,
+        durationMinutes: durationMinutes ?? 60,
+      })) as FreeSlot[];
+
+      // Filter to working hours if requested
+      let filteredSlots = freeSlots;
+      if (workingHoursOnly) {
+        filteredSlots = freeSlots.filter((slot: FreeSlot) => {
+          const startHour = slot.start.getHours();
+          const endHour = slot.end.getHours();
+          return startHour >= 9 && endHour <= 18;
+        });
+      }
+
+      // Format slots for display
+      const formattedSlots = filteredSlots.slice(0, 10).map((slot: FreeSlot) => {
+        const duration = Math.round(
+          (slot.end.getTime() - slot.start.getTime()) / (1000 * 60),
+        );
+        return {
+          start: slot.start.toISOString(),
+          end: slot.end.toISOString(),
+          durationMinutes: duration,
+          date: slot.start.toLocaleDateString("en-US", {
+            weekday: "long",
+            month: "short",
+            day: "numeric",
+          }),
+          timeRange: `${
+            slot.start.toLocaleTimeString("en-US", {
+              hour: "numeric",
+              minute: "2-digit",
+            })
+          } - ${
+            slot.end.toLocaleTimeString("en-US", {
+              hour: "numeric",
+              minute: "2-digit",
+            })
+          }`,
+        };
+      });
+
+      return {
+        freeSlots: formattedSlots,
+        count: formattedSlots.length,
+        searchCriteria: {
+          durationMinutes,
+          daysToSearch,
+          workingHoursOnly,
+        },
+        message: formattedSlots.length > 0
+          ? `Found ${formattedSlots.length} available slot(s) of ${durationMinutes} minutes or more.`
+          : `No free slots of ${durationMinutes} minutes found in the next ${daysToSearch} days.`,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Calendar not connected. Please connect your Google Calendar.",
+          connectUrl: "/api/auth/calendar",
+        };
+      }
+      throw error;
+    }
+  },
+});

package/dist/integrations/calendar/files/ai/tools/list-events.ts

@@ -0,0 +1,98 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createCalendarClient } from "../../lib/calendar-client.ts";
+
+export default tool({
+  id: "list-events",
+  description: "List upcoming calendar events. By default shows events from now onwards.",
+  inputSchema: z.object({
+    maxResults: z
+      .number()
+      .min(1)
+      .max(100)
+      .default(10)
+      .describe("Maximum number of events to return"),
+    daysAhead: z
+      .number()
+      .min(1)
+      .max(30)
+      .default(7)
+      .describe("Number of days to look ahead"),
+    todayOnly: z
+      .boolean()
+      .default(false)
+      .describe("Only show events for today"),
+  }),
+  execute: async ({ maxResults, daysAhead, todayOnly }, context) => {
+    const userId = context?.userId as string | undefined;
+    if (!userId) {
+      return {
+        error: "User not authenticated. Please log in first.",
+      };
+    }
+
+    try {
+      const calendar = createCalendarClient(userId);
+
+      let events;
+
+      if (todayOnly) {
+        events = await calendar.getTodayEvents();
+      } else {
+        const now = new Date();
+        const futureDate = new Date();
+        futureDate.setDate(futureDate.getDate() + (daysAhead ?? 7));
+
+        events = await calendar.listEvents({
+          maxResults,
+          timeMin: now,
+          timeMax: futureDate,
+        });
+      }
+
+      type CalendarEvent = {
+        id: string;
+        summary: string;
+        description?: string;
+        location?: string;
+        start: { dateTime?: string; date?: string };
+        end: { dateTime?: string; date?: string };
+        status: string;
+        htmlLink: string;
+        attendees?: Array<{ email: string; displayName?: string; responseStatus?: string }>;
+      };
+      return {
+        events: (events as CalendarEvent[]).map((event) => ({
+          id: event.id,
+          title: event.summary,
+          description: event.description || null,
+          location: event.location || null,
+          start: event.start.dateTime || event.start.date,
+          end: event.end.dateTime || event.end.date,
+          isAllDay: !event.start.dateTime,
+          status: event.status,
+          url: event.htmlLink,
+          attendees: event.attendees?.map((
+            a: { email: string; displayName?: string; responseStatus?: string },
+          ) => ({
+            email: a.email,
+            name: a.displayName,
+            status: a.responseStatus,
+          })) || [],
+        })),
+        count: events.length,
+        message: todayOnly
+          ? `Found ${events.length} event(s) for today.`
+          : `Found ${events.length} event(s) in the next ${daysAhead} days.`,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Calendar not connected. Please connect your Google Calendar.",
+          connectUrl: "/api/auth/calendar",
+        };
+      }
+      throw error;
+    }
+  },
+});