veryfront 0.0.49 → 0.0.50

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/outlook/files/lib/token-store.ts

@@ -0,0 +1,5 @@
+/**
+ * Outlook Token Store
+ */
+
+export { memoryTokenStore as tokenStore, type OAuthTokens, type TokenStore } from "veryfront/oauth";

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,
+    }));
+  },
+});

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

@@ -0,0 +1,46 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { updateDeal } from "../../lib/pipedrive-client.ts";
+
+export default tool({
+  id: "update-deal",
+  description: "Update an existing deal in Pipedrive with new information.",
+  inputSchema: z.object({
+    dealId: z.number().describe("The ID of the deal to update"),
+    title: z.string().optional().describe("New title/name for the deal"),
+    value: z.number().optional().describe("New monetary value for the deal"),
+    status: z.string().optional().describe("New status (e.g., open, won, lost)"),
+    stageId: z.number().optional().describe("New pipeline stage ID"),
+    personId: z.number().optional().describe("New person/contact ID"),
+    orgId: z.number().optional().describe("New organization ID"),
+    expectedCloseDate: z.string().optional().describe(
+      "New expected close date in YYYY-MM-DD format",
+    ),
+  }),
+  async execute({ dealId, title, value, status, stageId, personId, orgId, expectedCloseDate }) {
+    const deal = await updateDeal(dealId, {
+      title,
+      value,
+      status,
+      stageId,
+      personId,
+      orgId,
+      expectedCloseDate,
+    });
+
+    return {
+      success: true,
+      deal: {
+        id: deal.id,
+        title: deal.title,
+        value: deal.value,
+        status: deal.status,
+        stageId: deal.stage_id,
+        personName: deal.person_name,
+        orgName: deal.org_name,
+        expectedCloseDate: deal.expected_close_date,
+        updateTime: deal.update_time,
+      },
+    };
+  },
+});

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

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

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

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