veryfront 0.0.49 → 0.0.50

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

@@ -0,0 +1,91 @@
+/**
+ * Zendesk OAuth Callback Route
+ *
+ * Handles the OAuth callback and exchanges the code for tokens.
+ */
+
+import { setZendeskTokens } from "../../../../../lib/token-store.ts";
+
+const getEnv = (name: string): string | undefined => {
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore: Deno global
+    return Deno.env.get(name);
+  }
+  // @ts-ignore: Node process
+  return globalThis.process?.env?.[name];
+};
+
+export async function GET(request: Request): Promise<Response> {
+  const url = new URL(request.url);
+  const code = url.searchParams.get("code");
+  const error = url.searchParams.get("error");
+  const errorDescription = url.searchParams.get("error_description");
+
+  const baseUrl = getEnv("NEXT_PUBLIC_APP_URL") || `${url.protocol}//${url.host}`;
+
+  if (error) {
+    console.error("Zendesk OAuth error:", error, errorDescription);
+    return Response.redirect(
+      `${baseUrl}/?error=zendesk_oauth_failed&description=${
+        encodeURIComponent(errorDescription || error)
+      }`,
+      302,
+    );
+  }
+
+  if (!code) {
+    return Response.redirect(`${baseUrl}/?error=no_code`, 302);
+  }
+
+  const subdomain = getEnv("ZENDESK_SUBDOMAIN");
+  const clientId = getEnv("ZENDESK_CLIENT_ID");
+  const clientSecret = getEnv("ZENDESK_CLIENT_SECRET");
+
+  if (!subdomain || !clientId || !clientSecret) {
+    return Response.redirect(`${baseUrl}/?error=zendesk_not_configured`, 302);
+  }
+
+  const redirectUri = `${baseUrl}/api/auth/zendesk/callback`;
+
+  try {
+    // Exchange code for tokens
+    const tokenResponse = await fetch(
+      `https://${subdomain}.zendesk.com/oauth/tokens`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          grant_type: "authorization_code",
+          code,
+          client_id: clientId,
+          client_secret: clientSecret,
+          redirect_uri: redirectUri,
+          scope: "read write",
+        }),
+      },
+    );
+
+    if (!tokenResponse.ok) {
+      const errorText = await tokenResponse.text();
+      console.error("Zendesk token exchange failed:", errorText);
+      return Response.redirect(`${baseUrl}/?error=token_exchange_failed`, 302);
+    }
+
+    const tokens = await tokenResponse.json();
+
+    // Store tokens
+    await setZendeskTokens({
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token,
+      expiresAt: tokens.expires_in ? Date.now() + tokens.expires_in * 1000 : undefined,
+      subdomain,
+    });
+
+    return Response.redirect(`${baseUrl}/?connected=zendesk`, 302);
+  } catch (err) {
+    console.error("Zendesk OAuth error:", err);
+    return Response.redirect(`${baseUrl}/?error=zendesk_oauth_failed`, 302);
+  }
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Zendesk OAuth Init Route
+ *
+ * Redirects to Zendesk OAuth authorization page.
+ */
+
+const getEnv = (name: string): string | undefined => {
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore: Deno global
+    return Deno.env.get(name);
+  }
+  // @ts-ignore: Node process
+  return globalThis.process?.env?.[name];
+};
+
+export function GET(request: Request): Response {
+  const subdomain = getEnv("ZENDESK_SUBDOMAIN");
+  const clientId = getEnv("ZENDESK_CLIENT_ID");
+
+  if (!subdomain || !clientId) {
+    return Response.json(
+      { error: "Zendesk OAuth not configured" },
+      { status: 500 },
+    );
+  }
+
+  const url = new URL(request.url);
+  const baseUrl = getEnv("NEXT_PUBLIC_APP_URL") || `${url.protocol}//${url.host}`;
+  const redirectUri = `${baseUrl}/api/auth/zendesk/callback`;
+
+  const state = crypto.randomUUID();
+
+  const authUrl = new URL(`https://${subdomain}.zendesk.com/oauth/authorizations/new`);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", clientId);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("scope", "read write");
+  authUrl.searchParams.set("state", state);
+
+  return Response.redirect(authUrl.toString(), 302);
+}

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

@@ -0,0 +1,47 @@
+/**
+ * Zendesk Token Store
+ *
+ * Simple in-memory token storage for development.
+ * In production, use a persistent store like Redis or a database.
+ */
+
+export interface ZendeskTokens {
+  accessToken: string;
+  refreshToken?: string;
+  expiresAt?: number;
+  subdomain?: string;
+}
+
+// In-memory storage (replace with persistent storage in production)
+let tokens: ZendeskTokens | null = null;
+
+export function getZendeskTokens(): Promise<ZendeskTokens | null> {
+  return Promise.resolve(tokens);
+}
+
+export function setZendeskTokens(newTokens: ZendeskTokens): Promise<void> {
+  tokens = newTokens;
+  return Promise.resolve();
+}
+
+export function clearZendeskTokens(): Promise<void> {
+  tokens = null;
+  return Promise.resolve();
+}
+
+export async function isZendeskConnected(): Promise<boolean> {
+  const t = await getZendeskTokens();
+  if (!t) return false;
+
+  // Check if token is expired (with 5 minute buffer)
+  if (t.expiresAt && Date.now() > t.expiresAt - 5 * 60 * 1000) {
+    return false;
+  }
+
+  return true;
+}
+
+export async function getSubdomain(): Promise<string | null> {
+  const t = await getZendeskTokens();
+  return t?.subdomain || null;
+}

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

@@ -0,0 +1,265 @@
+/**
+ * Zendesk API Client
+ *
+ * Handles authentication and API calls to Zendesk REST API.
+ */
+
+import { getZendeskTokens } from "./token-store.ts";
+
+const getEnv = (name: string): string | undefined => {
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore: Deno global
+    return Deno.env.get(name);
+  }
+  // @ts-ignore: Node process
+  return globalThis.process?.env?.[name];
+};
+
+export interface ZendeskTicket {
+  id: number;
+  url: string;
+  subject: string;
+  description: string;
+  status: "new" | "open" | "pending" | "hold" | "solved" | "closed";
+  priority: "urgent" | "high" | "normal" | "low" | null;
+  type: "problem" | "incident" | "question" | "task" | null;
+  requester_id: number;
+  submitter_id: number;
+  assignee_id: number | null;
+  tags: string[];
+  created_at: string;
+  updated_at: string;
+  due_at: string | null;
+}
+
+export interface ZendeskUser {
+  id: number;
+  url: string;
+  name: string;
+  email: string;
+  role: "end-user" | "agent" | "admin";
+  phone: string | null;
+  photo: { url: string } | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface ZendeskComment {
+  id: number;
+  type: "Comment" | "VoiceComment";
+  author_id: number;
+  body: string;
+  html_body: string;
+  public: boolean;
+  created_at: string;
+}
+
+export interface ZendeskResponse<T> {
+  [key: string]: T;
+}
+
+export interface ZendeskListResponse<T> {
+  [key: string]: T[];
+  count?: number;
+  next_page?: string | null;
+  previous_page?: string | null;
+}
+
+export class ZendeskClient {
+  private subdomain: string;
+  private accessToken: string | null = null;
+
+  constructor() {
+    const subdomain = getEnv("ZENDESK_SUBDOMAIN");
+    if (!subdomain) {
+      throw new Error("ZENDESK_SUBDOMAIN not configured");
+    }
+    this.subdomain = subdomain;
+  }
+
+  private get baseUrl(): string {
+    return `https://${this.subdomain}.zendesk.com/api/v2`;
+  }
+
+  async ensureAuthenticated(): Promise<void> {
+    const tokens = await getZendeskTokens();
+    if (!tokens) {
+      throw new Error(
+        "Zendesk not connected. Please connect via /api/auth/zendesk",
+      );
+    }
+    this.accessToken = tokens.accessToken;
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    await this.ensureAuthenticated();
+
+    const url = `${this.baseUrl}${endpoint}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Zendesk API error: ${response.status} ${errorText}`);
+    }
+
+    return response.json();
+  }
+
+  /**
+   * List tickets with optional filters
+   */
+  async listTickets(options: {
+    limit?: number;
+    status?: string;
+    priority?: string;
+    assigneeId?: number;
+  } = {}): Promise<ZendeskTicket[]> {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("per_page", String(options.limit));
+
+    let endpoint = "/tickets.json";
+
+    // Build query if filters are provided
+    const queryParts: string[] = [];
+    if (options.status) queryParts.push(`status:${options.status}`);
+    if (options.priority) queryParts.push(`priority:${options.priority}`);
+    if (options.assigneeId) queryParts.push(`assignee:${options.assigneeId}`);
+
+    if (queryParts.length > 0) {
+      endpoint = `/search.json?query=type:ticket ${queryParts.join(" ")}`;
+      if (options.limit) endpoint += `&per_page=${options.limit}`;
+    } else if (params.toString()) {
+      endpoint += `?${params}`;
+    }
+
+    const response = await this.request<ZendeskListResponse<ZendeskTicket>>(endpoint);
+    return response.tickets || response.results || [];
+  }
+
+  /**
+   * Get a specific ticket by ID
+   */
+  async getTicket(ticketId: number): Promise<ZendeskTicket> {
+    const response = await this.request<ZendeskResponse<ZendeskTicket>>(
+      `/tickets/${ticketId}.json`,
+    );
+    return response.ticket;
+  }
+
+  /**
+   * Create a new ticket
+   */
+  async createTicket(data: {
+    subject: string;
+    comment: { body: string };
+    requester?: { name: string; email: string };
+    priority?: "urgent" | "high" | "normal" | "low";
+    type?: "problem" | "incident" | "question" | "task";
+    tags?: string[];
+    assignee_id?: number;
+  }): Promise<ZendeskTicket> {
+    const response = await this.request<ZendeskResponse<ZendeskTicket>>(
+      "/tickets.json",
+      {
+        method: "POST",
+        body: JSON.stringify({ ticket: data }),
+      },
+    );
+    return response.ticket;
+  }
+
+  /**
+   * Update an existing ticket
+   */
+  async updateTicket(
+    ticketId: number,
+    data: Partial<{
+      subject: string;
+      comment: { body: string; public: boolean };
+      status: "new" | "open" | "pending" | "hold" | "solved" | "closed";
+      priority: "urgent" | "high" | "normal" | "low";
+      assignee_id: number;
+      tags: string[];
+    }>,
+  ): Promise<ZendeskTicket> {
+    const response = await this.request<ZendeskResponse<ZendeskTicket>>(
+      `/tickets/${ticketId}.json`,
+      {
+        method: "PUT",
+        body: JSON.stringify({ ticket: data }),
+      },
+    );
+    return response.ticket;
+  }
+
+  /**
+   * List users
+   */
+  async listUsers(options: { limit?: number; role?: string } = {}): Promise<ZendeskUser[]> {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("per_page", String(options.limit));
+    if (options.role) params.set("role", options.role);
+
+    const endpoint = `/users.json${params.toString() ? `?${params}` : ""}`;
+    const response = await this.request<ZendeskListResponse<ZendeskUser>>(endpoint);
+    return response.users || [];
+  }
+
+  /**
+   * Get a specific user by ID
+   */
+  async getUser(userId: number): Promise<ZendeskUser> {
+    const response = await this.request<ZendeskResponse<ZendeskUser>>(
+      `/users/${userId}.json`,
+    );
+    return response.user;
+  }
+
+  /**
+   * Search tickets using Zendesk query syntax
+   */
+  async searchTickets(query: string, limit = 20): Promise<ZendeskTicket[]> {
+    const params = new URLSearchParams();
+    params.set("query", `type:ticket ${query}`);
+    params.set("per_page", String(limit));
+
+    const response = await this.request<ZendeskListResponse<ZendeskTicket>>(
+      `/search.json?${params}`,
+    );
+    return response.results || [];
+  }
+
+  /**
+   * Add a comment to a ticket
+   */
+  addComment(
+    ticketId: number,
+    body: string,
+    isPublic = true,
+  ): Promise<ZendeskTicket> {
+    return this.updateTicket(ticketId, {
+      comment: { body, public: isPublic },
+    });
+  }
+}
+
+// Singleton instance
+let client: ZendeskClient | null = null;
+
+export function getZendeskClient(): ZendeskClient {
+  if (!client) {
+    client = new ZendeskClient();
+  }
+  return client;
+}

package/dist/integrations/zoom/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "zoom",
+  "displayName": "Zoom",
+  "icon": "zoom.svg",
+  "description": "Manage video meetings and webinars in Zoom",
+  "auth": {
+    "type": "oauth2",
+    "provider": "zoom",
+    "authorizationUrl": "https://zoom.us/oauth/authorize",
+    "tokenUrl": "https://zoom.us/oauth/token",
+    "scopes": ["meeting:read", "meeting:write", "user:read"],
+    "callbackPath": "/api/auth/zoom/callback",
+    "requiredApis": [
+      {
+        "name": "Zoom Marketplace",
+        "enableUrl": "https://marketplace.zoom.us/develop/create"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "ZOOM_CLIENT_ID",
+      "description": "Zoom OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developers.zoom.us/docs/integrations/oauth/"
+    },
+    {
+      "name": "ZOOM_CLIENT_SECRET",
+      "description": "Zoom OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developers.zoom.us/docs/integrations/oauth/"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-meetings",
+      "name": "List Meetings",
+      "description": "List all scheduled meetings for a user",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-meeting",
+      "name": "Get Meeting",
+      "description": "Get details of a specific meeting",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-meeting",
+      "name": "Create Meeting",
+      "description": "Create a new Zoom meeting",
+      "requiresWrite": true
+    },
+    {
+      "id": "update-meeting",
+      "name": "Update Meeting",
+      "description": "Update an existing meeting",
+      "requiresWrite": true
+    },
+    {
+      "id": "delete-meeting",
+      "name": "Delete Meeting",
+      "description": "Delete a scheduled meeting",
+      "requiresWrite": true
+    }
+  ],
+  "prompts": [
+    {
+      "id": "my-meetings",
+      "title": "Show my meetings",
+      "prompt": "List all my upcoming Zoom meetings with their dates, times, and join URLs.",
+      "category": "productivity",
+      "icon": "video"
+    },
+    {
+      "id": "create-meeting",
+      "title": "Schedule a meeting",
+      "prompt": "Create a new Zoom meeting with a topic, time, duration, and password.",
+      "category": "productivity",
+      "icon": "plus"
+    }
+  ],
+  "suggestedWith": ["calendar", "slack", "notion"]
+}

package/dist/integrations/zoom/files/_env.example

@@ -0,0 +1,4 @@
+# Zoom OAuth Configuration
+# Get your credentials from https://marketplace.zoom.us/develop/create
+ZOOM_CLIENT_ID=your-client-id
+ZOOM_CLIENT_SECRET=your-client-secret

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

@@ -0,0 +1,106 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createMeeting } from "../../lib/zoom-client.ts";
+
+export default tool({
+  id: "create-meeting",
+  description: "Create a new Zoom meeting with specified settings.",
+  inputSchema: z.object({
+    topic: z.string().describe("The topic/title of the meeting"),
+    type: z
+      .enum(["1", "2", "3", "8"])
+      .transform((val) => parseInt(val) as 1 | 2 | 3 | 8)
+      .default("2")
+      .describe(
+        "Meeting type: 1=Instant, 2=Scheduled, 3=Recurring with no fixed time, 8=Recurring with fixed time",
+      ),
+    startTime: z
+      .string()
+      .optional()
+      .describe("Start time in ISO 8601 format (e.g., 2024-12-07T10:00:00Z)"),
+    duration: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Meeting duration in minutes"),
+    timezone: z
+      .string()
+      .optional()
+      .describe("Timezone (e.g., America/New_York, Europe/London)"),
+    password: z
+      .string()
+      .optional()
+      .describe("Meeting password"),
+    agenda: z
+      .string()
+      .optional()
+      .describe("Meeting agenda or description"),
+    hostVideo: z
+      .boolean()
+      .default(true)
+      .describe("Start video when host joins"),
+    participantVideo: z
+      .boolean()
+      .default(true)
+      .describe("Start video when participants join"),
+    joinBeforeHost: z
+      .boolean()
+      .default(false)
+      .describe("Allow participants to join before host"),
+    muteUponEntry: z
+      .boolean()
+      .default(false)
+      .describe("Mute participants upon entry"),
+    autoRecording: z
+      .enum(["local", "cloud", "none"])
+      .default("none")
+      .describe("Automatic recording setting"),
+  }),
+  async execute({
+    topic,
+    type,
+    startTime,
+    duration,
+    timezone,
+    password,
+    agenda,
+    hostVideo,
+    participantVideo,
+    joinBeforeHost,
+    muteUponEntry,
+    autoRecording,
+  }) {
+    const meeting = await createMeeting({
+      topic,
+      type,
+      startTime,
+      duration,
+      timezone,
+      password,
+      agenda,
+      settings: {
+        hostVideo,
+        participantVideo,
+        joinBeforeHost,
+        muteUponEntry,
+        autoRecording,
+        audio: "both",
+      },
+    });
+
+    return {
+      success: true,
+      meeting: {
+        id: meeting.id,
+        uuid: meeting.uuid,
+        topic: meeting.topic,
+        startTime: meeting.start_time,
+        duration: meeting.duration,
+        timezone: meeting.timezone,
+        joinUrl: meeting.join_url,
+        password: meeting.password,
+        hostEmail: meeting.host_email,
+      },
+    };
+  },
+});

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

@@ -0,0 +1,32 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { deleteMeeting } from "../../lib/zoom-client.ts";
+
+export default tool({
+  id: "delete-meeting",
+  description: "Delete a scheduled Zoom meeting.",
+  inputSchema: z.object({
+    meetingId: z
+      .union([z.string(), z.number()])
+      .describe("The meeting ID to delete"),
+    occurrenceId: z
+      .string()
+      .optional()
+      .describe("The meeting occurrence ID for recurring meetings"),
+    scheduleForReminder: z
+      .boolean()
+      .default(false)
+      .describe("Whether to send a reminder email to participants"),
+  }),
+  async execute({ meetingId, occurrenceId, scheduleForReminder }) {
+    await deleteMeeting(meetingId, {
+      occurrenceId,
+      scheduleForReminder,
+    });
+
+    return {
+      success: true,
+      message: `Meeting ${meetingId} deleted successfully`,
+    };
+  },
+});