veryfront 0.0.49 → 0.0.50

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

@@ -0,0 +1,393 @@
+import { getAccessToken } from "./token-store.ts";
+
+const HUBSPOT_BASE_URL = "https://api.hubapi.com";
+
+interface HubSpotPagination {
+  after?: string;
+  next?: {
+    after: string;
+    link: string;
+  };
+}
+
+interface HubSpotResponse<T> {
+  results: T[];
+  paging?: HubSpotPagination;
+}
+
+interface HubSpotContact {
+  id: string;
+  properties: {
+    email?: string;
+    firstname?: string;
+    lastname?: string;
+    phone?: string;
+    company?: string;
+    website?: string;
+    jobtitle?: string;
+    createdate?: string;
+    lastmodifieddate?: string;
+    [key: string]: string | undefined;
+  };
+  createdAt: string;
+  updatedAt: string;
+  archived: boolean;
+}
+
+interface HubSpotCompany {
+  id: string;
+  properties: {
+    name?: string;
+    domain?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    industry?: string;
+    phone?: string;
+    createdate?: string;
+    [key: string]: string | undefined;
+  };
+  createdAt: string;
+  updatedAt: string;
+  archived: boolean;
+}
+
+interface HubSpotDeal {
+  id: string;
+  properties: {
+    dealname?: string;
+    amount?: string;
+    dealstage?: string;
+    pipeline?: string;
+    closedate?: string;
+    createdate?: string;
+    [key: string]: string | undefined;
+  };
+  createdAt: string;
+  updatedAt: string;
+  archived: boolean;
+}
+
+async function hubspotFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with HubSpot. Please connect your account.");
+  }
+
+  const response = await fetch(`${HUBSPOT_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(
+      `HubSpot API error: ${response.status} ${error.message || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+// ============================================================================
+// CONTACTS
+// ============================================================================
+
+export function listContacts(options?: {
+  limit?: number;
+  after?: string;
+  properties?: string[];
+}): Promise<HubSpotResponse<HubSpotContact>> {
+  const params = new URLSearchParams();
+
+  if (options?.limit) {
+    params.set("limit", options.limit.toString());
+  }
+  if (options?.after) {
+    params.set("after", options.after);
+  }
+  if (options?.properties && options.properties.length > 0) {
+    options.properties.forEach((prop) => params.append("properties", prop));
+  } else {
+    // Default properties
+    ["email", "firstname", "lastname", "phone", "company", "jobtitle"].forEach(
+      (prop) => params.append("properties", prop),
+    );
+  }
+
+  const queryString = params.toString();
+  const url = `/crm/v3/objects/contacts${queryString ? `?${queryString}` : ""}`;
+
+  return hubspotFetch<HubSpotResponse<HubSpotContact>>(url);
+}
+
+export function getContact(
+  contactId: string,
+  properties?: string[],
+): Promise<HubSpotContact> {
+  const params = new URLSearchParams();
+
+  if (properties && properties.length > 0) {
+    properties.forEach((prop) => params.append("properties", prop));
+  } else {
+    ["email", "firstname", "lastname", "phone", "company", "jobtitle", "website"].forEach(
+      (prop) => params.append("properties", prop),
+    );
+  }
+
+  const queryString = params.toString();
+  const url = `/crm/v3/objects/contacts/${contactId}${queryString ? `?${queryString}` : ""}`;
+
+  return hubspotFetch<HubSpotContact>(url);
+}
+
+export function createContact(properties: {
+  email: string;
+  firstname?: string;
+  lastname?: string;
+  phone?: string;
+  company?: string;
+  website?: string;
+  jobtitle?: string;
+  [key: string]: string | undefined;
+}): Promise<HubSpotContact> {
+  return hubspotFetch<HubSpotContact>("/crm/v3/objects/contacts", {
+    method: "POST",
+    body: JSON.stringify({ properties }),
+  });
+}
+
+export function updateContact(
+  contactId: string,
+  properties: {
+    email?: string;
+    firstname?: string;
+    lastname?: string;
+    phone?: string;
+    company?: string;
+    website?: string;
+    jobtitle?: string;
+    [key: string]: string | undefined;
+  },
+): Promise<HubSpotContact> {
+  return hubspotFetch<HubSpotContact>(`/crm/v3/objects/contacts/${contactId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ properties }),
+  });
+}
+
+export function searchContacts(options: {
+  query?: string;
+  filterGroups?: Array<{
+    filters: Array<{
+      propertyName: string;
+      operator: string;
+      value: string;
+    }>;
+  }>;
+  properties?: string[];
+  limit?: number;
+  after?: string;
+}): Promise<HubSpotResponse<HubSpotContact>> {
+  const body: Record<string, unknown> = {};
+
+  if (options.filterGroups) {
+    body.filterGroups = options.filterGroups;
+  }
+
+  if (options.properties && options.properties.length > 0) {
+    body.properties = options.properties;
+  } else {
+    body.properties = ["email", "firstname", "lastname", "phone", "company", "jobtitle"];
+  }
+
+  if (options.limit) {
+    body.limit = options.limit;
+  }
+
+  if (options.after) {
+    body.after = options.after;
+  }
+
+  return hubspotFetch<HubSpotResponse<HubSpotContact>>("/crm/v3/objects/contacts/search", {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+}
+
+// ============================================================================
+// COMPANIES
+// ============================================================================
+
+export function listCompanies(options?: {
+  limit?: number;
+  after?: string;
+  properties?: string[];
+}): Promise<HubSpotResponse<HubSpotCompany>> {
+  const params = new URLSearchParams();
+
+  if (options?.limit) {
+    params.set("limit", options.limit.toString());
+  }
+  if (options?.after) {
+    params.set("after", options.after);
+  }
+  if (options?.properties && options.properties.length > 0) {
+    options.properties.forEach((prop) => params.append("properties", prop));
+  } else {
+    ["name", "domain", "city", "state", "industry", "phone"].forEach(
+      (prop) => params.append("properties", prop),
+    );
+  }
+
+  const queryString = params.toString();
+  const url = `/crm/v3/objects/companies${queryString ? `?${queryString}` : ""}`;
+
+  return hubspotFetch<HubSpotResponse<HubSpotCompany>>(url);
+}
+
+export function getCompany(
+  companyId: string,
+  properties?: string[],
+): Promise<HubSpotCompany> {
+  const params = new URLSearchParams();
+
+  if (properties && properties.length > 0) {
+    properties.forEach((prop) => params.append("properties", prop));
+  } else {
+    ["name", "domain", "city", "state", "country", "industry", "phone"].forEach(
+      (prop) => params.append("properties", prop),
+    );
+  }
+
+  const queryString = params.toString();
+  const url = `/crm/v3/objects/companies/${companyId}${queryString ? `?${queryString}` : ""}`;
+
+  return hubspotFetch<HubSpotCompany>(url);
+}
+
+export function createCompany(properties: {
+  name: string;
+  domain?: string;
+  city?: string;
+  state?: string;
+  country?: string;
+  industry?: string;
+  phone?: string;
+  [key: string]: string | undefined;
+}): Promise<HubSpotCompany> {
+  return hubspotFetch<HubSpotCompany>("/crm/v3/objects/companies", {
+    method: "POST",
+    body: JSON.stringify({ properties }),
+  });
+}
+
+// ============================================================================
+// DEALS
+// ============================================================================
+
+export function listDeals(options?: {
+  limit?: number;
+  after?: string;
+  properties?: string[];
+}): Promise<HubSpotResponse<HubSpotDeal>> {
+  const params = new URLSearchParams();
+
+  if (options?.limit) {
+    params.set("limit", options.limit.toString());
+  }
+  if (options?.after) {
+    params.set("after", options.after);
+  }
+  if (options?.properties && options.properties.length > 0) {
+    options.properties.forEach((prop) => params.append("properties", prop));
+  } else {
+    ["dealname", "amount", "dealstage", "pipeline", "closedate"].forEach(
+      (prop) => params.append("properties", prop),
+    );
+  }
+
+  const queryString = params.toString();
+  const url = `/crm/v3/objects/deals${queryString ? `?${queryString}` : ""}`;
+
+  return hubspotFetch<HubSpotResponse<HubSpotDeal>>(url);
+}
+
+export function getDeal(
+  dealId: string,
+  properties?: string[],
+): Promise<HubSpotDeal> {
+  const params = new URLSearchParams();
+
+  if (properties && properties.length > 0) {
+    properties.forEach((prop) => params.append("properties", prop));
+  } else {
+    ["dealname", "amount", "dealstage", "pipeline", "closedate"].forEach(
+      (prop) => params.append("properties", prop),
+    );
+  }
+
+  const queryString = params.toString();
+  const url = `/crm/v3/objects/deals/${dealId}${queryString ? `?${queryString}` : ""}`;
+
+  return hubspotFetch<HubSpotDeal>(url);
+}
+
+export function createDeal(properties: {
+  dealname: string;
+  amount?: string;
+  dealstage?: string;
+  pipeline?: string;
+  closedate?: string;
+  [key: string]: string | undefined;
+}): Promise<HubSpotDeal> {
+  return hubspotFetch<HubSpotDeal>("/crm/v3/objects/deals", {
+    method: "POST",
+    body: JSON.stringify({ properties }),
+  });
+}
+
+export function updateDeal(
+  dealId: string,
+  properties: {
+    dealname?: string;
+    amount?: string;
+    dealstage?: string;
+    pipeline?: string;
+    closedate?: string;
+    [key: string]: string | undefined;
+  },
+): Promise<HubSpotDeal> {
+  return hubspotFetch<HubSpotDeal>(`/crm/v3/objects/deals/${dealId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ properties }),
+  });
+}
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+export function formatContactName(contact: HubSpotContact): string {
+  const parts = [];
+  if (contact.properties.firstname) parts.push(contact.properties.firstname);
+  if (contact.properties.lastname) parts.push(contact.properties.lastname);
+  return parts.length > 0 ? parts.join(" ") : contact.properties.email || "Unnamed Contact";
+}
+
+export function formatCompanyName(company: HubSpotCompany): string {
+  return company.properties.name || company.properties.domain || "Unnamed Company";
+}
+
+export function formatDealName(deal: HubSpotDeal): string {
+  return deal.properties.dealname || "Unnamed Deal";
+}
+
+export type { HubSpotCompany, HubSpotContact, HubSpotDeal, HubSpotResponse };

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

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

package/dist/integrations/intercom/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "intercom",
+  "displayName": "Intercom",
+  "icon": "intercom.svg",
+  "description": "Customer messaging platform for support and engagement",
+  "auth": {
+    "type": "oauth2",
+    "provider": "intercom",
+    "authorizationUrl": "https://app.intercom.com/oauth",
+    "tokenUrl": "https://api.intercom.io/auth/eagle/token",
+    "scopes": [],
+    "callbackPath": "/api/auth/intercom/callback",
+    "requiredApis": [
+      {
+        "name": "Intercom Developer Hub",
+        "enableUrl": "https://developers.intercom.com/building-apps/"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "INTERCOM_CLIENT_ID",
+      "description": "Intercom OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developers.intercom.com/building-apps/docs/setting-up-oauth"
+    },
+    {
+      "name": "INTERCOM_CLIENT_SECRET",
+      "description": "Intercom OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developers.intercom.com/building-apps/docs/setting-up-oauth"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-contacts",
+      "name": "List Contacts",
+      "description": "List contacts from Intercom workspace",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-contact",
+      "name": "Get Contact",
+      "description": "Get details of a specific contact",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-conversations",
+      "name": "List Conversations",
+      "description": "List conversations from Intercom",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-conversation",
+      "name": "Get Conversation",
+      "description": "Get details of a specific conversation",
+      "requiresWrite": false
+    },
+    {
+      "id": "send-message",
+      "name": "Send Message",
+      "description": "Send a message in a conversation",
+      "requiresWrite": true
+    }
+  ],
+  "prompts": [
+    {
+      "id": "recent-conversations",
+      "title": "Show recent conversations",
+      "prompt": "List the most recent customer conversations from Intercom with their status and priority.",
+      "category": "support",
+      "icon": "message-circle"
+    },
+    {
+      "id": "find-contact",
+      "title": "Find a contact",
+      "prompt": "Search for a contact in Intercom and show their details and conversation history.",
+      "category": "support",
+      "icon": "user"
+    }
+  ],
+  "suggestedWith": ["slack", "zendesk", "hubspot"]
+}

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

@@ -0,0 +1,4 @@
+# Intercom OAuth Configuration
+# Get your credentials from https://developers.intercom.com/building-apps/
+INTERCOM_CLIENT_ID=your-client-id
+INTERCOM_CLIENT_SECRET=your-client-secret

package/dist/integrations/intercom/files/ai/tools/get-contact.ts

@@ -0,0 +1,35 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getContact } from "../../lib/intercom-client.ts";
+
+export default tool({
+  id: "get-contact",
+  description: "Get details of a specific contact from Intercom by their ID.",
+  inputSchema: z.object({
+    contactId: z.string().describe("The ID of the contact to retrieve"),
+  }),
+  async execute({ contactId }) {
+    const contact = await getContact(contactId);
+
+    return {
+      id: contact.id,
+      email: contact.email,
+      name: contact.name,
+      phone: contact.phone,
+      role: contact.role,
+      externalId: contact.external_id,
+      avatar: contact.avatar,
+      createdAt: new Date(contact.created_at * 1000).toISOString(),
+      updatedAt: new Date(contact.updated_at * 1000).toISOString(),
+      signedUpAt: contact.signed_up_at
+        ? new Date(contact.signed_up_at * 1000).toISOString()
+        : null,
+      lastSeenAt: contact.last_seen_at
+        ? new Date(contact.last_seen_at * 1000).toISOString()
+        : null,
+      ownerId: contact.owner_id,
+      customAttributes: contact.custom_attributes,
+      tags: contact.tags?.map((tag) => ({ id: tag.id, name: tag.name })),
+    };
+  },
+});

package/dist/integrations/intercom/files/ai/tools/get-conversation.ts

@@ -0,0 +1,55 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getConversation } from "../../lib/intercom-client.ts";
+
+export default tool({
+  id: "get-conversation",
+  description: "Get details of a specific conversation from Intercom, including all conversation parts/messages.",
+  inputSchema: z.object({
+    conversationId: z.string().describe("The ID of the conversation to retrieve"),
+  }),
+  async execute({ conversationId }) {
+    const conversation = await getConversation(conversationId);
+
+    return {
+      id: conversation.id,
+      title: conversation.title,
+      state: conversation.state,
+      read: conversation.read,
+      priority: conversation.priority,
+      createdAt: new Date(conversation.created_at * 1000).toISOString(),
+      updatedAt: new Date(conversation.updated_at * 1000).toISOString(),
+      waitingSince: conversation.waiting_since
+        ? new Date(conversation.waiting_since * 1000).toISOString()
+        : null,
+      snoozedUntil: conversation.snoozed_until
+        ? new Date(conversation.snoozed_until * 1000).toISOString()
+        : null,
+      source: {
+        type: conversation.source.type,
+        subject: conversation.source.subject,
+        body: conversation.source.body,
+        author: {
+          type: conversation.source.author.type,
+          id: conversation.source.author.id,
+          name: conversation.source.author.name,
+          email: conversation.source.author.email,
+        },
+      },
+      conversationParts: conversation.conversation_parts?.conversation_parts.map((part) => ({
+        id: part.id,
+        partType: part.part_type,
+        body: part.body,
+        createdAt: new Date(part.created_at * 1000).toISOString(),
+        author: {
+          type: part.author.type,
+          id: part.author.id,
+          name: part.author.name,
+          email: part.author.email,
+        },
+      })) || [],
+      contactIds: conversation.contacts?.map((c) => c.id),
+      teammateIds: conversation.teammates?.map((t) => t.id),
+    };
+  },
+});

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

@@ -0,0 +1,35 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listContacts } from "../../lib/intercom-client.ts";
+
+export default tool({
+  id: "list-contacts",
+  description: "List contacts from Intercom workspace. Returns contact information including email, name, and metadata.",
+  inputSchema: z.object({
+    page: z.number().min(1).default(1).describe("Page number for pagination"),
+    perPage: z.number().min(1).max(150).default(50).describe("Number of contacts per page (max 150)"),
+    limit: z.number().min(1).max(100).default(20).describe("Maximum number of contacts to return"),
+  }),
+  async execute({ page, perPage, limit }) {
+    const { contacts, hasMore } = await listContacts({ page, perPage });
+
+    return {
+      contacts: contacts.slice(0, limit).map((contact) => ({
+        id: contact.id,
+        email: contact.email,
+        name: contact.name,
+        phone: contact.phone,
+        role: contact.role,
+        createdAt: new Date(contact.created_at * 1000).toISOString(),
+        updatedAt: new Date(contact.updated_at * 1000).toISOString(),
+        lastSeenAt: contact.last_seen_at
+          ? new Date(contact.last_seen_at * 1000).toISOString()
+          : null,
+        ownerId: contact.owner_id,
+        tags: contact.tags?.map((tag) => tag.name),
+      })),
+      hasMore,
+      page,
+    };
+  },
+});

package/dist/integrations/intercom/files/ai/tools/list-conversations.ts

@@ -0,0 +1,49 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listConversations } from "../../lib/intercom-client.ts";
+
+export default tool({
+  id: "list-conversations",
+  description: "List conversations from Intercom. Can filter by open/closed status.",
+  inputSchema: z.object({
+    page: z.number().min(1).default(1).describe("Page number for pagination"),
+    perPage: z.number().min(1).max(150).default(50).describe("Number of conversations per page (max 150)"),
+    open: z.boolean().optional().describe("Filter by open (true) or closed (false) conversations"),
+    limit: z.number().min(1).max(50).default(20).describe("Maximum number of conversations to return"),
+  }),
+  async execute({ page, perPage, open, limit }) {
+    const { conversations, hasMore } = await listConversations({ page, perPage, open });
+
+    return {
+      conversations: conversations.slice(0, limit).map((conv) => ({
+        id: conv.id,
+        title: conv.title,
+        state: conv.state,
+        read: conv.read,
+        priority: conv.priority,
+        createdAt: new Date(conv.created_at * 1000).toISOString(),
+        updatedAt: new Date(conv.updated_at * 1000).toISOString(),
+        waitingSince: conv.waiting_since
+          ? new Date(conv.waiting_since * 1000).toISOString()
+          : null,
+        snoozedUntil: conv.snoozed_until
+          ? new Date(conv.snoozed_until * 1000).toISOString()
+          : null,
+        source: {
+          type: conv.source.type,
+          subject: conv.source.subject,
+          body: conv.source.body,
+          author: {
+            id: conv.source.author.id,
+            name: conv.source.author.name,
+            email: conv.source.author.email,
+          },
+        },
+        contactIds: conv.contacts?.map((c) => c.id),
+        teammateIds: conv.teammates?.map((t) => t.id),
+      })),
+      hasMore,
+      page,
+    };
+  },
+});

package/dist/integrations/intercom/files/ai/tools/send-message.ts

@@ -0,0 +1,34 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { sendMessage } from "../../lib/intercom-client.ts";
+
+export default tool({
+  id: "send-message",
+  description: "Send a message or reply to an existing conversation in Intercom.",
+  inputSchema: z.object({
+    conversationId: z.string().describe("The ID of the conversation to reply to"),
+    body: z.string().describe("The message content to send"),
+    messageType: z.enum(["comment", "note"]).default("comment").describe(
+      "Type of message: 'comment' (visible to user) or 'note' (internal only)",
+    ),
+    adminId: z.string().optional().describe("The ID of the admin sending the message"),
+  }),
+  async execute({ conversationId, body, messageType, adminId }) {
+    const conversation = await sendMessage({
+      conversationId,
+      body,
+      messageType,
+      adminId,
+    });
+
+    return {
+      success: true,
+      conversation: {
+        id: conversation.id,
+        state: conversation.state,
+        updatedAt: new Date(conversation.updated_at * 1000).toISOString(),
+      },
+      message: `Message sent successfully to conversation ${conversationId}`,
+    };
+  },
+});