veryfront 0.0.48 → 0.0.50

package/dist/integrations/zoom/files/ai/tools/get-meeting.ts

@@ -0,0 +1,44 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getMeeting } from "../../lib/zoom-client.ts";
+
+export default tool({
+  id: "get-meeting",
+  description: "Get detailed information about a specific Zoom meeting by its ID.",
+  inputSchema: z.object({
+    meetingId: z
+      .union([z.string(), z.number()])
+      .describe("The meeting ID or UUID"),
+  }),
+  async execute({ meetingId }) {
+    const meeting = await getMeeting(meetingId);
+
+    return {
+      id: meeting.id,
+      uuid: meeting.uuid,
+      topic: meeting.topic,
+      type: meeting.type,
+      startTime: meeting.start_time,
+      duration: meeting.duration,
+      timezone: meeting.timezone,
+      agenda: meeting.agenda,
+      joinUrl: meeting.join_url,
+      password: meeting.password,
+      hostId: meeting.host_id,
+      hostEmail: meeting.host_email,
+      status: meeting.status,
+      createdAt: meeting.created_at,
+      settings: meeting.settings
+        ? {
+            hostVideo: meeting.settings.host_video,
+            participantVideo: meeting.settings.participant_video,
+            joinBeforeHost: meeting.settings.join_before_host,
+            muteUponEntry: meeting.settings.mute_upon_entry,
+            watermark: meeting.settings.watermark,
+            audio: meeting.settings.audio,
+            autoRecording: meeting.settings.auto_recording,
+          }
+        : undefined,
+    };
+  },
+});

package/dist/integrations/zoom/files/ai/tools/list-meetings.ts

@@ -0,0 +1,47 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listMeetings } from "../../lib/zoom-client.ts";
+
+export default tool({
+  id: "list-meetings",
+  description:
+    "List Zoom meetings for the current user. Can filter by meeting type (scheduled, live, upcoming, etc.).",
+  inputSchema: z.object({
+    type: z
+      .enum(["scheduled", "live", "upcoming", "upcoming_meetings", "previous_meetings"])
+      .default("scheduled")
+      .describe("Type of meetings to list"),
+    pageSize: z
+      .number()
+      .min(1)
+      .max(300)
+      .default(30)
+      .describe("Number of meetings to return per page"),
+    pageNumber: z
+      .number()
+      .min(1)
+      .default(1)
+      .describe("Page number for pagination"),
+  }),
+  async execute({ type, pageSize, pageNumber }) {
+    const meetings = await listMeetings({
+      type,
+      pageSize,
+      pageNumber,
+    });
+
+    return meetings.map((meeting) => ({
+      id: meeting.id,
+      uuid: meeting.uuid,
+      topic: meeting.topic,
+      type: meeting.type,
+      startTime: meeting.start_time,
+      duration: meeting.duration,
+      timezone: meeting.timezone,
+      agenda: meeting.agenda,
+      joinUrl: meeting.join_url,
+      password: meeting.password,
+      status: meeting.status,
+    }));
+  },
+});

package/dist/integrations/zoom/files/ai/tools/update-meeting.ts

@@ -0,0 +1,111 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { updateMeeting } from "../../lib/zoom-client.ts";
+
+export default tool({
+  id: "update-meeting",
+  description: "Update an existing Zoom meeting with new settings.",
+  inputSchema: z.object({
+    meetingId: z
+      .union([z.string(), z.number()])
+      .describe("The meeting ID to update"),
+    topic: z
+      .string()
+      .optional()
+      .describe("The new topic/title of the meeting"),
+    type: z
+      .enum(["1", "2", "3", "8"])
+      .transform((val) => parseInt(val) as 1 | 2 | 3 | 8)
+      .optional()
+      .describe(
+        "Meeting type: 1=Instant, 2=Scheduled, 3=Recurring with no fixed time, 8=Recurring with fixed time",
+      ),
+    startTime: z
+      .string()
+      .optional()
+      .describe("New start time in ISO 8601 format"),
+    duration: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("New meeting duration in minutes"),
+    timezone: z
+      .string()
+      .optional()
+      .describe("New timezone"),
+    password: z
+      .string()
+      .optional()
+      .describe("New meeting password"),
+    agenda: z
+      .string()
+      .optional()
+      .describe("New meeting agenda or description"),
+    hostVideo: z
+      .boolean()
+      .optional()
+      .describe("Start video when host joins"),
+    participantVideo: z
+      .boolean()
+      .optional()
+      .describe("Start video when participants join"),
+    joinBeforeHost: z
+      .boolean()
+      .optional()
+      .describe("Allow participants to join before host"),
+    muteUponEntry: z
+      .boolean()
+      .optional()
+      .describe("Mute participants upon entry"),
+    autoRecording: z
+      .enum(["local", "cloud", "none"])
+      .optional()
+      .describe("Automatic recording setting"),
+  }),
+  async execute({
+    meetingId,
+    topic,
+    type,
+    startTime,
+    duration,
+    timezone,
+    password,
+    agenda,
+    hostVideo,
+    participantVideo,
+    joinBeforeHost,
+    muteUponEntry,
+    autoRecording,
+  }) {
+    const settings =
+      hostVideo !== undefined ||
+      participantVideo !== undefined ||
+      joinBeforeHost !== undefined ||
+      muteUponEntry !== undefined ||
+      autoRecording !== undefined
+        ? {
+            hostVideo,
+            participantVideo,
+            joinBeforeHost,
+            muteUponEntry,
+            autoRecording,
+          }
+        : undefined;
+
+    await updateMeeting(meetingId, {
+      topic,
+      type,
+      startTime,
+      duration,
+      timezone,
+      password,
+      agenda,
+      settings,
+    });
+
+    return {
+      success: true,
+      message: `Meeting ${meetingId} updated successfully`,
+    };
+  },
+});

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

@@ -0,0 +1,11 @@
+/**
+ * Zoom OAuth Callback
+ */
+
+import { zoomConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthCallbackHandler(zoomConfig, {
+  tokenStore: memoryTokenStore,
+  onSuccess: () => "/",
+  onError: () => "/",
+});

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

@@ -0,0 +1,7 @@
+/**
+ * Zoom OAuth Init
+ */
+
+import { zoomConfig, createOAuthInitHandler } from "veryfront/oauth";
+
+export const GET = createOAuthInitHandler(zoomConfig);

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

@@ -0,0 +1,11 @@
+/**
+ * Zoom Token Store
+ */
+
+export { memoryTokenStore as tokenStore, type OAuthTokens, type TokenStore } from "veryfront/oauth";
+
+export async function getAccessToken(): Promise<string | null> {
+  const { tokenStore } = await import("./token-store.ts");
+  const tokens = await tokenStore.get("zoom");
+  return tokens?.accessToken ?? null;
+}

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

@@ -0,0 +1,228 @@
+import { getAccessToken } from "./token-store.ts";
+
+const ZOOM_BASE_URL = "https://api.zoom.us/v2";
+
+interface ZoomMeeting {
+  id: number;
+  uuid: string;
+  topic: string;
+  type: number;
+  start_time: string;
+  duration: number;
+  timezone: string;
+  agenda: string;
+  created_at: string;
+  join_url: string;
+  password?: string;
+  host_id: string;
+  host_email: string;
+  status: string;
+  settings?: {
+    host_video: boolean;
+    participant_video: boolean;
+    join_before_host: boolean;
+    mute_upon_entry: boolean;
+    watermark: boolean;
+    audio: string;
+    auto_recording: string;
+  };
+}
+
+interface ZoomUser {
+  id: string;
+  first_name: string;
+  last_name: string;
+  email: string;
+  type: number;
+  pmi: number;
+  timezone: string;
+  verified: number;
+  created_at: string;
+  last_login_time: string;
+  pic_url: string;
+}
+
+interface ZoomMeetingList {
+  meetings: ZoomMeeting[];
+  page_count: number;
+  page_number: number;
+  page_size: number;
+  total_records: number;
+}
+
+async function zoomFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Zoom. Please connect your account.");
+  }
+
+  const response = await fetch(`${ZOOM_BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Zoom API error: ${response.status} ${error.message || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function getUser(): Promise<ZoomUser> {
+  const user = await zoomFetch<ZoomUser>("/users/me");
+  return user;
+}
+
+export async function listMeetings(options: {
+  userId?: string;
+  type?: "scheduled" | "live" | "upcoming" | "upcoming_meetings" | "previous_meetings";
+  pageSize?: number;
+  pageNumber?: number;
+} = {}): Promise<ZoomMeeting[]> {
+  const userId = options.userId || "me";
+  const params = new URLSearchParams({
+    type: options.type || "scheduled",
+    page_size: String(options.pageSize || 30),
+    page_number: String(options.pageNumber || 1),
+  });
+
+  const response = await zoomFetch<ZoomMeetingList>(
+    `/users/${userId}/meetings?${params}`,
+  );
+  return response.meetings;
+}
+
+export async function getMeeting(meetingId: string | number): Promise<ZoomMeeting> {
+  const meeting = await zoomFetch<ZoomMeeting>(`/meetings/${meetingId}`);
+  return meeting;
+}
+
+export async function createMeeting(options: {
+  userId?: string;
+  topic: string;
+  type?: 1 | 2 | 3 | 8; // 1=Instant, 2=Scheduled, 3=Recurring with no fixed time, 8=Recurring with fixed time
+  startTime?: string; // ISO 8601 format
+  duration?: number; // In minutes
+  timezone?: string;
+  password?: string;
+  agenda?: string;
+  settings?: {
+    hostVideo?: boolean;
+    participantVideo?: boolean;
+    joinBeforeHost?: boolean;
+    muteUponEntry?: boolean;
+    watermark?: boolean;
+    audio?: "both" | "telephony" | "voip";
+    autoRecording?: "local" | "cloud" | "none";
+  };
+}): Promise<ZoomMeeting> {
+  const userId = options.userId || "me";
+  const body: Record<string, unknown> = {
+    topic: options.topic,
+    type: options.type || 2,
+  };
+
+  if (options.startTime) body.start_time = options.startTime;
+  if (options.duration) body.duration = options.duration;
+  if (options.timezone) body.timezone = options.timezone;
+  if (options.password) body.password = options.password;
+  if (options.agenda) body.agenda = options.agenda;
+
+  if (options.settings) {
+    body.settings = {
+      host_video: options.settings.hostVideo,
+      participant_video: options.settings.participantVideo,
+      join_before_host: options.settings.joinBeforeHost,
+      mute_upon_entry: options.settings.muteUponEntry,
+      watermark: options.settings.watermark,
+      audio: options.settings.audio,
+      auto_recording: options.settings.autoRecording,
+    };
+  }
+
+  const meeting = await zoomFetch<ZoomMeeting>(`/users/${userId}/meetings`, {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+  return meeting;
+}
+
+export async function updateMeeting(
+  meetingId: string | number,
+  updates: {
+    topic?: string;
+    type?: 1 | 2 | 3 | 8;
+    startTime?: string;
+    duration?: number;
+    timezone?: string;
+    password?: string;
+    agenda?: string;
+    settings?: {
+      hostVideo?: boolean;
+      participantVideo?: boolean;
+      joinBeforeHost?: boolean;
+      muteUponEntry?: boolean;
+      watermark?: boolean;
+      audio?: "both" | "telephony" | "voip";
+      autoRecording?: "local" | "cloud" | "none";
+    };
+  },
+): Promise<void> {
+  const body: Record<string, unknown> = {};
+
+  if (updates.topic !== undefined) body.topic = updates.topic;
+  if (updates.type !== undefined) body.type = updates.type;
+  if (updates.startTime !== undefined) body.start_time = updates.startTime;
+  if (updates.duration !== undefined) body.duration = updates.duration;
+  if (updates.timezone !== undefined) body.timezone = updates.timezone;
+  if (updates.password !== undefined) body.password = updates.password;
+  if (updates.agenda !== undefined) body.agenda = updates.agenda;
+
+  if (updates.settings) {
+    body.settings = {
+      host_video: updates.settings.hostVideo,
+      participant_video: updates.settings.participantVideo,
+      join_before_host: updates.settings.joinBeforeHost,
+      mute_upon_entry: updates.settings.muteUponEntry,
+      watermark: updates.settings.watermark,
+      audio: updates.settings.audio,
+      auto_recording: updates.settings.autoRecording,
+    };
+  }
+
+  await zoomFetch<void>(`/meetings/${meetingId}`, {
+    method: "PATCH",
+    body: JSON.stringify(body),
+  });
+}
+
+export async function deleteMeeting(
+  meetingId: string | number,
+  options?: {
+    occurrenceId?: string;
+    scheduleForReminder?: boolean;
+  },
+): Promise<void> {
+  const params = new URLSearchParams();
+  if (options?.occurrenceId) params.set("occurrence_id", options.occurrenceId);
+  if (options?.scheduleForReminder !== undefined) {
+    params.set("schedule_for_reminder", String(options.scheduleForReminder));
+  }
+
+  const queryString = params.toString();
+  const endpoint = `/meetings/${meetingId}${queryString ? `?${queryString}` : ""}`;
+
+  await zoomFetch<void>(endpoint, {
+    method: "DELETE",
+  });
+}