veryfront 0.0.49 → 0.0.50

package/dist/integrations/freshdesk/files/ai/tools/list-contacts.ts

@@ -0,0 +1,37 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listContacts } from "../../lib/freshdesk-client.ts";
+
+export default tool({
+  id: "list-contacts",
+  description:
+    "List customer contacts from Freshdesk. Can filter by email, phone, mobile, or company ID.",
+  inputSchema: z.object({
+    email: z.string().optional().describe("Filter by contact email address"),
+    phone: z.string().optional().describe("Filter by contact phone number"),
+    mobile: z.string().optional().describe("Filter by contact mobile number"),
+    companyId: z.number().optional().describe("Filter by company ID"),
+    limit: z.number().min(1).max(100).default(30).describe("Maximum number of contacts to return"),
+  }),
+  async execute({ email, phone, mobile, companyId, limit }) {
+    const contacts = await listContacts({
+      email,
+      phone,
+      mobile,
+      companyId,
+      perPage: limit,
+    });
+
+    return contacts.map((contact) => ({
+      id: contact.id,
+      name: contact.name,
+      email: contact.email,
+      phone: contact.phone,
+      mobile: contact.mobile,
+      companyId: contact.company_id,
+      createdAt: contact.created_at,
+      updatedAt: contact.updated_at,
+      tags: contact.tags,
+    }));
+  },
+});

package/dist/integrations/freshdesk/files/ai/tools/list-tickets.ts

@@ -0,0 +1,59 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listTickets, TicketStatus, TicketPriority } from "../../lib/freshdesk-client.ts";
+
+export default tool({
+  id: "list-tickets",
+  description:
+    "List support tickets from Freshdesk. Can filter by status, priority, and type.",
+  inputSchema: z.object({
+    status: z
+      .enum(["open", "pending", "resolved", "closed"])
+      .optional()
+      .describe("Filter by ticket status"),
+    priority: z
+      .enum(["low", "medium", "high", "urgent"])
+      .optional()
+      .describe("Filter by ticket priority"),
+    type: z
+      .string()
+      .optional()
+      .describe("Filter by ticket type (e.g., 'Question', 'Incident', 'Problem', 'Feature Request')"),
+    limit: z.number().min(1).max(100).default(30).describe("Maximum number of tickets to return"),
+  }),
+  async execute({ status, priority, type, limit }) {
+    const statusMap = {
+      open: TicketStatus.OPEN,
+      pending: TicketStatus.PENDING,
+      resolved: TicketStatus.RESOLVED,
+      closed: TicketStatus.CLOSED,
+    };
+
+    const priorityMap = {
+      low: TicketPriority.LOW,
+      medium: TicketPriority.MEDIUM,
+      high: TicketPriority.HIGH,
+      urgent: TicketPriority.URGENT,
+    };
+
+    const tickets = await listTickets({
+      status: status ? statusMap[status] : undefined,
+      priority: priority ? priorityMap[priority] : undefined,
+      type,
+      perPage: limit,
+    });
+
+    return tickets.map((ticket) => ({
+      id: ticket.id,
+      subject: ticket.subject,
+      description: ticket.description_text,
+      status: Object.keys(statusMap).find((key) => statusMap[key as keyof typeof statusMap] === ticket.status) || "unknown",
+      priority: Object.keys(priorityMap).find((key) => priorityMap[key as keyof typeof priorityMap] === ticket.priority) || "unknown",
+      type: ticket.type,
+      dueBy: ticket.due_by,
+      createdAt: ticket.created_at,
+      updatedAt: ticket.updated_at,
+      tags: ticket.tags,
+    }));
+  },
+});

package/dist/integrations/freshdesk/files/ai/tools/update-ticket.ts

@@ -0,0 +1,61 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { updateTicket, TicketStatus, TicketPriority } from "../../lib/freshdesk-client.ts";
+
+export default tool({
+  id: "update-ticket",
+  description: "Update an existing Freshdesk support ticket.",
+  inputSchema: z.object({
+    ticketId: z.number().describe("The ID of the ticket to update"),
+    subject: z.string().optional().describe("New subject/title for the ticket"),
+    description: z.string().optional().describe("New description or details"),
+    status: z
+      .enum(["open", "pending", "resolved", "closed"])
+      .optional()
+      .describe("New status for the ticket"),
+    priority: z
+      .enum(["low", "medium", "high", "urgent"])
+      .optional()
+      .describe("New priority level"),
+    type: z
+      .string()
+      .optional()
+      .describe("New type of ticket (e.g., 'Question', 'Incident', 'Problem', 'Feature Request')"),
+    tags: z.array(z.string()).optional().describe("New tags for the ticket (replaces existing tags)"),
+  }),
+  async execute({ ticketId, subject, description, status, priority, type, tags }) {
+    const priorityMap = {
+      low: TicketPriority.LOW,
+      medium: TicketPriority.MEDIUM,
+      high: TicketPriority.HIGH,
+      urgent: TicketPriority.URGENT,
+    };
+
+    const statusMap = {
+      open: TicketStatus.OPEN,
+      pending: TicketStatus.PENDING,
+      resolved: TicketStatus.RESOLVED,
+      closed: TicketStatus.CLOSED,
+    };
+
+    const ticket = await updateTicket(ticketId, {
+      subject,
+      description,
+      status: status ? statusMap[status] : undefined,
+      priority: priority ? priorityMap[priority] : undefined,
+      type,
+      tags,
+    });
+
+    return {
+      success: true,
+      ticket: {
+        id: ticket.id,
+        subject: ticket.subject,
+        status: Object.keys(statusMap).find((key) => statusMap[key as keyof typeof statusMap] === ticket.status) || "unknown",
+        priority: Object.keys(priorityMap).find((key) => priorityMap[key as keyof typeof priorityMap] === ticket.priority) || "unknown",
+        updatedAt: ticket.updated_at,
+      },
+    };
+  },
+});

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

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

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

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

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

@@ -0,0 +1,178 @@
+import { getAccessToken } from "./token-store.ts";
+
+const FRESHDESK_BASE_URL = "https://domain.freshdesk.com/api/v2";
+
+interface FreshdeskTicket {
+  id: number;
+  subject: string;
+  description: string;
+  description_text: string;
+  status: number;
+  priority: number;
+  type: string;
+  requester_id: number;
+  responder_id: number | null;
+  due_by: string;
+  fr_due_by: string;
+  created_at: string;
+  updated_at: string;
+  tags: string[];
+  custom_fields: Record<string, unknown>;
+}
+
+interface FreshdeskContact {
+  id: number;
+  name: string;
+  email: string;
+  phone: string | null;
+  mobile: string | null;
+  company_id: number | null;
+  created_at: string;
+  updated_at: string;
+  tags: string[];
+  custom_fields: Record<string, unknown>;
+}
+
+async function freshdeskFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Freshdesk. Please connect your account.");
+  }
+
+  const response = await fetch(`${FRESHDESK_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(
+      `Freshdesk API error: ${response.status} ${error.description || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function listTickets(options: {
+  status?: number;
+  priority?: number;
+  type?: string;
+  page?: number;
+  perPage?: number;
+} = {}): Promise<FreshdeskTicket[]> {
+  const params = new URLSearchParams();
+
+  if (options.status !== undefined) params.set("status", options.status.toString());
+  if (options.priority !== undefined) params.set("priority", options.priority.toString());
+  if (options.type) params.set("type", options.type);
+  if (options.page) params.set("page", options.page.toString());
+  if (options.perPage) params.set("per_page", options.perPage.toString());
+
+  const queryString = params.toString();
+  const endpoint = queryString ? `/tickets?${queryString}` : "/tickets";
+
+  return freshdeskFetch<FreshdeskTicket[]>(endpoint);
+}
+
+export async function getTicket(ticketId: number): Promise<FreshdeskTicket> {
+  return freshdeskFetch<FreshdeskTicket>(`/tickets/${ticketId}`);
+}
+
+export async function createTicket(options: {
+  subject: string;
+  description: string;
+  email: string;
+  priority?: number;
+  status?: number;
+  type?: string;
+  tags?: string[];
+}): Promise<FreshdeskTicket> {
+  const body: Record<string, unknown> = {
+    subject: options.subject,
+    description: options.description,
+    email: options.email,
+    priority: options.priority ?? 1,
+    status: options.status ?? 2,
+  };
+
+  if (options.type) body.type = options.type;
+  if (options.tags) body.tags = options.tags;
+
+  return freshdeskFetch<FreshdeskTicket>("/tickets", {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+}
+
+export async function updateTicket(
+  ticketId: number,
+  updates: {
+    subject?: string;
+    description?: string;
+    status?: number;
+    priority?: number;
+    type?: string;
+    tags?: string[];
+  },
+): Promise<FreshdeskTicket> {
+  const body: Record<string, unknown> = {};
+
+  if (updates.subject !== undefined) body.subject = updates.subject;
+  if (updates.description !== undefined) body.description = updates.description;
+  if (updates.status !== undefined) body.status = updates.status;
+  if (updates.priority !== undefined) body.priority = updates.priority;
+  if (updates.type !== undefined) body.type = updates.type;
+  if (updates.tags !== undefined) body.tags = updates.tags;
+
+  return freshdeskFetch<FreshdeskTicket>(`/tickets/${ticketId}`, {
+    method: "PUT",
+    body: JSON.stringify(body),
+  });
+}
+
+export async function listContacts(options: {
+  email?: string;
+  mobile?: string;
+  phone?: string;
+  companyId?: number;
+  page?: number;
+  perPage?: number;
+} = {}): Promise<FreshdeskContact[]> {
+  const params = new URLSearchParams();
+
+  if (options.email) params.set("email", options.email);
+  if (options.mobile) params.set("mobile", options.mobile);
+  if (options.phone) params.set("phone", options.phone);
+  if (options.companyId) params.set("company_id", options.companyId.toString());
+  if (options.page) params.set("page", options.page.toString());
+  if (options.perPage) params.set("per_page", options.perPage.toString());
+
+  const queryString = params.toString();
+  const endpoint = queryString ? `/contacts?${queryString}` : "/contacts";
+
+  return freshdeskFetch<FreshdeskContact[]>(endpoint);
+}
+
+// Ticket status constants
+export const TicketStatus = {
+  OPEN: 2,
+  PENDING: 3,
+  RESOLVED: 4,
+  CLOSED: 5,
+} as const;
+
+// Ticket priority constants
+export const TicketPriority = {
+  LOW: 1,
+  MEDIUM: 2,
+  HIGH: 3,
+  URGENT: 4,
+} as const;

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

@@ -0,0 +1,11 @@
+/**
+ * Freshdesk 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("freshdesk");
+  return tokens?.accessToken ?? null;
+}

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

@@ -1,132 +1,11 @@
 /**
  * GitHub OAuth Callback
- *
- * Handles the OAuth callback from GitHub, exchanges code for tokens,
- * and stores them securely.
  */
 
-import { tokenStore } from "../../../../../lib/token-store.ts";
-import { githubOAuthProvider } from "../../../../../lib/github-client.ts";
+import { createOAuthCallbackHandler, githubConfig, memoryTokenStore } from "veryfront/oauth";
 
-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>GitHub 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("github_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}${githubOAuthProvider.callbackPath}`;
-
-    // Exchange code for tokens
-    const response = await fetch(githubOAuthProvider.tokenUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        Accept: "application/json",
-      },
-      body: new URLSearchParams({
-        client_id: githubOAuthProvider.clientId,
-        client_secret: githubOAuthProvider.clientSecret,
-        code,
-        redirect_uri: redirectUri,
-      }),
-    });
-
-    const data = await response.json();
-
-    if (data.error) {
-      throw new Error(data.error_description || data.error);
-    }
-
-    // Get actual user ID from session in production
-    const userId = "current-user";
-
-    // Store tokens
-    await tokenStore.setToken(userId, "github", {
-      accessToken: data.access_token,
-      refreshToken: data.refresh_token,
-      scope: data.scope,
-      tokenType: data.token_type,
-    });
-
-    // Clear state cookie and redirect to success page
-    return new Response(
-      `
-      <html>
-        <head>
-          <title>GitHub 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;">✓ GitHub Connected!</h1>
-          <p style="color: #666;">Your GitHub 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": "github_oauth_state=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
-        },
-      },
-    );
-  } catch (err) {
-    console.error("GitHub 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>GitHub Connection Failed</h1>
-          <p style="color: #666;">Unable to complete GitHub authorization. Please try again.</p>
-          <a href="/api/auth/github" style="color: #0066cc;">Try Again</a>
-        </body>
-      </html>
-      `,
-      {
-        status: 500,
-        headers: { "Content-Type": "text/html" },
-      },
-    );
-  }
-}
+export const GET = createOAuthCallbackHandler(githubConfig, {
+  tokenStore: memoryTokenStore,
+  onSuccess: () => "/",
+  onError: () => "/",
+});

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

@@ -1,29 +1,9 @@
 /**
  * GitHub OAuth Initiation
- *
- * Redirects to GitHub OAuth consent screen
  */
 
-import { getAuthorizationUrl } from "../../../../lib/oauth.ts";
-import { githubOAuthProvider } from "../../../../lib/github-client.ts";
+import { createOAuthInitHandler, githubConfig, memoryTokenStore } from "veryfront/oauth";
 
-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}${githubOAuthProvider.callbackPath}`;
-  const authUrl = getAuthorizationUrl(githubOAuthProvider, state, redirectUri);
-
-  // Set state cookie and redirect to GitHub
-  return new Response(null, {
-    status: 302,
-    headers: {
-      Location: authUrl,
-      "Set-Cookie": `github_oauth_state=${state}; Path=/; HttpOnly; SameSite=Lax; Max-Age=600`,
-    },
-  });
-}
+export const GET = createOAuthInitHandler(githubConfig, {
+  tokenStore: memoryTokenStore,
+});

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

@@ -1,113 +1,5 @@
 /**
- * OAuth Token Store
- *
- * Simple in-memory token store for development.
- * Replace with a database or KV store for production.
+ * GitHub Token Store
  */
 
-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
-// Use globalThis to share across esbuild bundles (each API route is bundled separately)
-const TOKENS_KEY = "__veryfront_oauth_tokens__";
-// deno-lint-ignore no-explicit-any
-const globalStore = globalThis as any;
-const tokens: Map<string, OAuthToken> = globalStore[TOKENS_KEY] ||= 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();
-    },
-  };
-}
+export { memoryTokenStore as tokenStore, type OAuthTokens, type TokenStore } from "veryfront/oauth";