veryfront 0.0.49 → 0.0.51

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

@@ -0,0 +1,8 @@
+# Microsoft Outlook Integration
+# Get these from: https://portal.azure.com/#view/Microsoft_AAD_RegisteredApps/ApplicationsListBlade
+
+# Your Microsoft Azure App Client ID (Application ID)
+MICROSOFT_CLIENT_ID=your_client_id_here
+
+# Your Microsoft Azure App Client Secret
+MICROSOFT_CLIENT_SECRET=your_client_secret_here

package/dist/integrations/outlook/files/ai/tools/get-email.ts

@@ -0,0 +1,47 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getEmail } from "../../lib/outlook-client.ts";
+
+export default tool({
+  id: "get-email",
+  description:
+    "Get detailed information about a specific email, including full body content, recipients, and metadata.",
+  inputSchema: z.object({
+    messageId: z.string().describe("The ID of the email message to retrieve"),
+    includeBody: z.boolean().default(true).describe("Include full email body content"),
+  }),
+  async execute({ messageId, includeBody }) {
+    const message = await getEmail(messageId);
+
+    return {
+      id: message.id,
+      subject: message.subject,
+      from: {
+        name: message.from.emailAddress.name,
+        email: message.from.emailAddress.address,
+      },
+      to: message.toRecipients.map((r) => ({
+        name: r.emailAddress.name,
+        email: r.emailAddress.address,
+      })),
+      cc: message.ccRecipients?.map((r) => ({
+        name: r.emailAddress.name,
+        email: r.emailAddress.address,
+      })),
+      body: includeBody
+        ? {
+          contentType: message.body.contentType,
+          content: message.body.content,
+        }
+        : undefined,
+      bodyPreview: message.bodyPreview,
+      receivedAt: message.receivedDateTime,
+      sentAt: message.sentDateTime,
+      isRead: message.isRead,
+      hasAttachments: message.hasAttachments,
+      importance: message.importance,
+      conversationId: message.conversationId,
+      webLink: message.webLink,
+    };
+  },
+});

package/dist/integrations/outlook/files/ai/tools/list-emails.ts

@@ -0,0 +1,46 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listEmails } from "../../lib/outlook-client.ts";
+
+export default tool({
+  id: "list-emails",
+  description:
+    "List recent emails from inbox or a specific folder. Returns email metadata including subject, sender, date, and preview.",
+  inputSchema: z.object({
+    folderId: z.string().optional().describe("Folder ID to list emails from (default: inbox)"),
+    limit: z.number().min(1).max(50).default(10).describe("Maximum number of emails to return"),
+    unreadOnly: z.boolean().default(false).describe("Only return unread emails"),
+    orderBy: z.enum(["receivedDateTime desc", "receivedDateTime asc", "subject"]).default(
+      "receivedDateTime desc",
+    ).describe("Sort order for emails"),
+  }),
+  async execute({ folderId, limit, unreadOnly, orderBy }) {
+    const filter = unreadOnly ? "isRead eq false" : undefined;
+
+    const messages = await listEmails({
+      folderId,
+      top: limit,
+      filter,
+      orderBy,
+    });
+
+    return messages.map((msg) => ({
+      id: msg.id,
+      subject: msg.subject,
+      from: {
+        name: msg.from.emailAddress.name,
+        email: msg.from.emailAddress.address,
+      },
+      to: msg.toRecipients.map((r) => ({
+        name: r.emailAddress.name,
+        email: r.emailAddress.address,
+      })),
+      preview: msg.bodyPreview,
+      receivedAt: msg.receivedDateTime,
+      isRead: msg.isRead,
+      hasAttachments: msg.hasAttachments,
+      importance: msg.importance,
+      webLink: msg.webLink,
+    }));
+  },
+});

package/dist/integrations/outlook/files/ai/tools/list-folders.ts

@@ -0,0 +1,22 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listFolders } from "../../lib/outlook-client.ts";
+
+export default tool({
+  id: "list-folders",
+  description:
+    "List all mail folders in the mailbox, including inbox, sent items, drafts, and custom folders.",
+  inputSchema: z.object({}),
+  async execute() {
+    const folders = await listFolders();
+
+    return folders.map((folder) => ({
+      id: folder.id,
+      name: folder.displayName,
+      parentFolderId: folder.parentFolderId,
+      childFolderCount: folder.childFolderCount,
+      unreadItemCount: folder.unreadItemCount,
+      totalItemCount: folder.totalItemCount,
+    }));
+  },
+});

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

@@ -0,0 +1,41 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { searchEmails } from "../../lib/outlook-client.ts";
+
+export default tool({
+  id: "search-emails",
+  description:
+    "Search emails by query string. Searches across subject, body, sender, and recipients. Supports advanced search syntax.",
+  inputSchema: z.object({
+    query: z.string().min(1).describe("Search query (searches subject, body, from, to fields)"),
+    limit: z.number().min(1).max(50).default(10).describe("Maximum number of results to return"),
+  }),
+  async execute({ query, limit }) {
+    const messages = await searchEmails({
+      query,
+      top: limit,
+    });
+
+    return {
+      totalResults: messages.length,
+      emails: messages.map((msg) => ({
+        id: msg.id,
+        subject: msg.subject,
+        from: {
+          name: msg.from.emailAddress.name,
+          email: msg.from.emailAddress.address,
+        },
+        to: msg.toRecipients.map((r) => ({
+          name: r.emailAddress.name,
+          email: r.emailAddress.address,
+        })),
+        preview: msg.bodyPreview,
+        receivedAt: msg.receivedDateTime,
+        isRead: msg.isRead,
+        hasAttachments: msg.hasAttachments,
+        importance: msg.importance,
+        webLink: msg.webLink,
+      })),
+    };
+  },
+});

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

@@ -0,0 +1,41 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { sendEmail } from "../../lib/outlook-client.ts";
+
+export default tool({
+  id: "send-email",
+  description:
+    "Send a new email message. Supports multiple recipients, CC, BCC, and importance levels.",
+  inputSchema: z.object({
+    to: z.array(z.string().email()).min(1).describe("Email addresses of recipients"),
+    subject: z.string().min(1).describe("Email subject line"),
+    body: z.string().min(1).describe("Email body content"),
+    cc: z.array(z.string().email()).optional().describe("Email addresses to CC"),
+    bcc: z.array(z.string().email()).optional().describe("Email addresses to BCC"),
+    importance: z.enum(["low", "normal", "high"]).default("normal").describe(
+      "Email importance level",
+    ),
+    bodyType: z.enum(["text", "html"]).default("text").describe("Body content type (text or html)"),
+  }),
+  async execute({ to, subject, body, cc, bcc, importance, bodyType }) {
+    await sendEmail({
+      to,
+      subject,
+      body,
+      cc,
+      bcc,
+      importance,
+      bodyType,
+    });
+
+    return {
+      success: true,
+      message: `Email sent successfully to ${to.join(", ")}`,
+      recipients: {
+        to,
+        cc,
+        bcc,
+      },
+    };
+  },
+});

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * Outlook OAuth Initiation
+ */
+
+import { createOAuthInitHandler, memoryTokenStore, outlookConfig } from "veryfront/oauth";
+
+export const GET = createOAuthInitHandler(outlookConfig, {
+  tokenStore: memoryTokenStore,
+});

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

@@ -0,0 +1,204 @@
+import { getAccessToken } from "./token-store.ts";
+
+const GRAPH_BASE_URL = "https://graph.microsoft.com/v1.0";
+
+interface GraphResponse<T> {
+  value?: T[];
+  "@odata.nextLink"?: string;
+}
+
+export interface OutlookMessage {
+  id: string;
+  subject: string;
+  bodyPreview: string;
+  body: {
+    contentType: "text" | "html";
+    content: string;
+  };
+  from: {
+    emailAddress: {
+      name: string;
+      address: string;
+    };
+  };
+  toRecipients: Array<{
+    emailAddress: {
+      name: string;
+      address: string;
+    };
+  }>;
+  ccRecipients?: Array<{
+    emailAddress: {
+      name: string;
+      address: string;
+    };
+  }>;
+  receivedDateTime: string;
+  sentDateTime: string;
+  isRead: boolean;
+  hasAttachments: boolean;
+  importance: "low" | "normal" | "high";
+  conversationId: string;
+  webLink: string;
+}
+
+export interface OutlookFolder {
+  id: string;
+  displayName: string;
+  parentFolderId: string;
+  childFolderCount: number;
+  unreadItemCount: number;
+  totalItemCount: number;
+}
+
+export interface SendEmailOptions {
+  to: string[];
+  subject: string;
+  body: string;
+  cc?: string[];
+  bcc?: string[];
+  importance?: "low" | "normal" | "high";
+  bodyType?: "text" | "html";
+}
+
+async function graphFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Microsoft. Please connect your account.");
+  }
+
+  const response = await fetch(`${GRAPH_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(
+      `Microsoft Graph API error: ${response.status} ${
+        error.error?.message || response.statusText
+      }`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function listEmails(options?: {
+  folderId?: string;
+  top?: number;
+  skip?: number;
+  filter?: string;
+  orderBy?: string;
+}): Promise<OutlookMessage[]> {
+  const params = new URLSearchParams();
+
+  if (options?.top) params.set("$top", options.top.toString());
+  if (options?.skip) params.set("$skip", options.skip.toString());
+  if (options?.filter) params.set("$filter", options.filter);
+  if (options?.orderBy) params.set("$orderby", options.orderBy);
+
+  const folderPath = options?.folderId ? `/mailFolders/${options.folderId}/messages` : "/messages";
+
+  const queryString = params.toString();
+  const endpoint = `${folderPath}${queryString ? `?${queryString}` : ""}`;
+
+  const response = await graphFetch<GraphResponse<OutlookMessage>>(endpoint);
+  return response.value || [];
+}
+
+export function getEmail(messageId: string): Promise<OutlookMessage> {
+  return graphFetch<OutlookMessage>(`/messages/${messageId}`);
+}
+
+export async function sendEmail(options: SendEmailOptions): Promise<void> {
+  const message = {
+    subject: options.subject,
+    body: {
+      contentType: options.bodyType || "text",
+      content: options.body,
+    },
+    toRecipients: options.to.map((email) => ({
+      emailAddress: { address: email },
+    })),
+    ccRecipients: options.cc?.map((email) => ({
+      emailAddress: { address: email },
+    })),
+    bccRecipients: options.bcc?.map((email) => ({
+      emailAddress: { address: email },
+    })),
+    importance: options.importance || "normal",
+  };
+
+  await graphFetch("/sendMail", {
+    method: "POST",
+    body: JSON.stringify({ message }),
+  });
+}
+
+export async function searchEmails(options: {
+  query: string;
+  top?: number;
+  skip?: number;
+}): Promise<OutlookMessage[]> {
+  const params = new URLSearchParams();
+  params.set("$search", `"${options.query}"`);
+
+  if (options.top) params.set("$top", options.top.toString());
+  if (options.skip) params.set("$skip", options.skip.toString());
+
+  const response = await graphFetch<GraphResponse<OutlookMessage>>(
+    `/messages?${params.toString()}`,
+  );
+  return response.value || [];
+}
+
+export async function listFolders(): Promise<OutlookFolder[]> {
+  const response = await graphFetch<GraphResponse<OutlookFolder>>("/mailFolders");
+  return response.value || [];
+}
+
+export async function markAsRead(messageId: string): Promise<void> {
+  await graphFetch(`/messages/${messageId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ isRead: true }),
+  });
+}
+
+export async function markAsUnread(messageId: string): Promise<void> {
+  await graphFetch(`/messages/${messageId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ isRead: false }),
+  });
+}
+
+export async function deleteEmail(messageId: string): Promise<void> {
+  await graphFetch(`/messages/${messageId}`, {
+    method: "DELETE",
+  });
+}
+
+export async function moveEmail(messageId: string, destinationFolderId: string): Promise<void> {
+  await graphFetch(`/messages/${messageId}/move`, {
+    method: "POST",
+    body: JSON.stringify({ destinationId: destinationFolderId }),
+  });
+}
+
+// Helper to format email for display
+export function formatEmail(message: OutlookMessage): string {
+  return `From: ${message.from.emailAddress.name || message.from.emailAddress.address}
+To: ${message.toRecipients.map((r) => r.emailAddress.address).join(", ")}
+Subject: ${message.subject}
+Date: ${new Date(message.receivedDateTime).toLocaleString()}
+Read: ${message.isRead ? "Yes" : "No"}
+
+${message.bodyPreview}`;
+}

package/dist/integrations/pipedrive/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "pipedrive",
+  "displayName": "Pipedrive",
+  "icon": "pipedrive.svg",
+  "description": "Manage deals, contacts, and sales pipeline in Pipedrive",
+  "auth": {
+    "type": "oauth2",
+    "provider": "pipedrive",
+    "authorizationUrl": "https://oauth.pipedrive.com/oauth/authorize",
+    "tokenUrl": "https://oauth.pipedrive.com/oauth/token",
+    "scopes": [],
+    "callbackPath": "/api/auth/pipedrive/callback",
+    "requiredApis": [
+      {
+        "name": "Pipedrive Developer Hub",
+        "enableUrl": "https://developers.pipedrive.com/docs/marketplace"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "PIPEDRIVE_CLIENT_ID",
+      "description": "Pipedrive OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developers.pipedrive.com/docs/marketplace/oauth"
+    },
+    {
+      "name": "PIPEDRIVE_CLIENT_SECRET",
+      "description": "Pipedrive OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developers.pipedrive.com/docs/marketplace/oauth"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-deals",
+      "name": "List Deals",
+      "description": "List deals in the sales pipeline",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-deal",
+      "name": "Get Deal",
+      "description": "Get details of a specific deal",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-deal",
+      "name": "Create Deal",
+      "description": "Create a new deal in the pipeline",
+      "requiresWrite": true
+    },
+    {
+      "id": "update-deal",
+      "name": "Update Deal",
+      "description": "Update an existing deal",
+      "requiresWrite": true
+    },
+    {
+      "id": "list-persons",
+      "name": "List Persons",
+      "description": "List contacts/persons in Pipedrive",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "my-deals",
+      "title": "Show my deals",
+      "prompt": "List all deals in my Pipedrive pipeline with their values and stages.",
+      "category": "sales",
+      "icon": "currency"
+    },
+    {
+      "id": "create-deal",
+      "title": "Create a deal",
+      "prompt": "Create a new deal with a title, value, and contact person.",
+      "category": "sales",
+      "icon": "plus"
+    }
+  ],
+  "suggestedWith": ["hubspot", "salesforce", "slack"]
+}

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

@@ -0,0 +1,4 @@
+# Pipedrive OAuth Configuration
+# Get your credentials from https://developers.pipedrive.com/docs/marketplace
+PIPEDRIVE_CLIENT_ID=your-client-id
+PIPEDRIVE_CLIENT_SECRET=your-client-secret

package/dist/integrations/pipedrive/files/ai/tools/create-deal.ts

@@ -0,0 +1,44 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createDeal } from "../../lib/pipedrive-client.ts";
+
+export default tool({
+  id: "create-deal",
+  description: "Create a new deal in the Pipedrive sales pipeline.",
+  inputSchema: z.object({
+    title: z.string().describe("The title/name of the deal"),
+    value: z.number().optional().describe("The monetary value of the deal"),
+    currency: z.string().default("USD").describe("Currency code (e.g., USD, EUR, GBP)"),
+    personId: z.number().optional().describe("ID of the person/contact associated with the deal"),
+    orgId: z.number().optional().describe("ID of the organization associated with the deal"),
+    stageId: z.number().optional().describe("ID of the pipeline stage for the deal"),
+    expectedCloseDate: z.string().optional().describe(
+      "Expected close date in YYYY-MM-DD format",
+    ),
+  }),
+  async execute({ title, value, currency, personId, orgId, stageId, expectedCloseDate }) {
+    const deal = await createDeal({
+      title,
+      value,
+      currency,
+      personId,
+      orgId,
+      stageId,
+      expectedCloseDate,
+    });
+
+    return {
+      success: true,
+      deal: {
+        id: deal.id,
+        title: deal.title,
+        value: deal.value,
+        currency: deal.currency,
+        stageId: deal.stage_id,
+        personName: deal.person_name,
+        orgName: deal.org_name,
+        expectedCloseDate: deal.expected_close_date,
+      },
+    };
+  },
+});

package/dist/integrations/pipedrive/files/ai/tools/get-deal.ts

@@ -0,0 +1,34 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getDeal } from "../../lib/pipedrive-client.ts";
+
+export default tool({
+  id: "get-deal",
+  description: "Get detailed information about a specific deal in Pipedrive by its ID.",
+  inputSchema: z.object({
+    dealId: z.number().describe("The ID of the deal to retrieve"),
+  }),
+  async execute({ dealId }) {
+    const deal = await getDeal(dealId);
+
+    return {
+      id: deal.id,
+      title: deal.title,
+      value: deal.value,
+      currency: deal.currency,
+      status: deal.status,
+      stageId: deal.stage_id,
+      personId: deal.person_id,
+      personName: deal.person_name,
+      orgId: deal.org_id,
+      orgName: deal.org_name,
+      ownerName: deal.owner_name,
+      expectedCloseDate: deal.expected_close_date,
+      addTime: deal.add_time,
+      updateTime: deal.update_time,
+      wonTime: deal.won_time,
+      lostTime: deal.lost_time,
+      closeTime: deal.close_time,
+    };
+  },
+});

package/dist/integrations/pipedrive/files/ai/tools/list-deals.ts

@@ -0,0 +1,40 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listDeals } from "../../lib/pipedrive-client.ts";
+
+export default tool({
+  id: "list-deals",
+  description:
+    "List deals from Pipedrive. Can filter by status, owner, or stage to get specific deals in the sales pipeline.",
+  inputSchema: z.object({
+    status: z.enum(["open", "won", "lost", "all"]).default("open").describe(
+      "Filter deals by status",
+    ),
+    ownerId: z.number().optional().describe("Filter deals by owner user ID"),
+    stageId: z.number().optional().describe("Filter deals by stage ID"),
+    limit: z.number().min(1).max(100).default(20).describe("Maximum number of deals to return"),
+  }),
+  async execute({ status, ownerId, stageId, limit }) {
+    const deals = await listDeals({
+      status,
+      ownerId,
+      stageId,
+      limit,
+    });
+
+    return deals.map((deal) => ({
+      id: deal.id,
+      title: deal.title,
+      value: deal.value,
+      currency: deal.currency,
+      status: deal.status,
+      stageId: deal.stage_id,
+      personName: deal.person_name,
+      orgName: deal.org_name,
+      ownerName: deal.owner_name,
+      expectedCloseDate: deal.expected_close_date,
+      addTime: deal.add_time,
+      updateTime: deal.update_time,
+    }));
+  },
+});

package/dist/integrations/pipedrive/files/ai/tools/list-persons.ts

@@ -0,0 +1,33 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listPersons } from "../../lib/pipedrive-client.ts";
+
+export default tool({
+  id: "list-persons",
+  description:
+    "List contacts/persons from Pipedrive. Can optionally search by name or email.",
+  inputSchema: z.object({
+    searchTerm: z.string().optional().describe("Search term to filter persons by name or email"),
+    limit: z.number().min(1).max(100).default(20).describe("Maximum number of persons to return"),
+  }),
+  async execute({ searchTerm, limit }) {
+    const persons = await listPersons({
+      searchTerm,
+      limit,
+    });
+
+    return persons.map((person) => ({
+      id: person.id,
+      name: person.name,
+      firstName: person.first_name,
+      lastName: person.last_name,
+      email: person.email?.[0]?.value || null,
+      phone: person.phone?.[0]?.value || null,
+      orgId: person.org_id,
+      orgName: person.org_name,
+      ownerName: person.owner_name,
+      addTime: person.add_time,
+      updateTime: person.update_time,
+    }));
+  },
+});