veryfront 0.0.49 → 0.0.50

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

@@ -0,0 +1,252 @@
+import { getAccessToken } from "./token-store.ts";
+
+const QUICKBOOKS_BASE_URL = "https://quickbooks.api.intuit.com/v3";
+
+// Note: QuickBooks requires a realmId (company ID) which should be stored during OAuth
+// For this template, we'll use an environment variable or parameter
+const getRealmId = (): string => {
+  const realmId = process.env.QUICKBOOKS_REALM_ID;
+  if (!realmId) {
+    throw new Error("QUICKBOOKS_REALM_ID environment variable is required");
+  }
+  return realmId;
+};
+
+interface QuickBooksResponse<T> {
+  QueryResponse?: {
+    [key: string]: T[];
+    maxResults?: number;
+    startPosition?: number;
+  };
+  Invoice?: T;
+  Customer?: T;
+  time?: string;
+}
+
+interface QuickBooksInvoice {
+  Id: string;
+  DocNumber: string;
+  TxnDate: string;
+  DueDate?: string;
+  TotalAmt: number;
+  Balance: number;
+  CustomerRef: {
+    value: string;
+    name: string;
+  };
+  Line: Array<{
+    Id: string;
+    LineNum: number;
+    Description?: string;
+    Amount: number;
+    DetailType: string;
+    SalesItemLineDetail?: {
+      ItemRef: {
+        value: string;
+        name: string;
+      };
+      Qty?: number;
+      UnitPrice?: number;
+    };
+  }>;
+  EmailStatus?: string;
+  BillEmail?: {
+    Address: string;
+  };
+  TxnStatus?: string;
+  MetaData?: {
+    CreateTime: string;
+    LastUpdatedTime: string;
+  };
+}
+
+interface QuickBooksCustomer {
+  Id: string;
+  DisplayName: string;
+  CompanyName?: string;
+  GivenName?: string;
+  FamilyName?: string;
+  PrimaryEmailAddr?: {
+    Address: string;
+  };
+  PrimaryPhone?: {
+    FreeFormNumber: string;
+  };
+  BillAddr?: {
+    Line1?: string;
+    City?: string;
+    CountrySubDivisionCode?: string;
+    PostalCode?: string;
+  };
+  Balance: number;
+  Active: boolean;
+  MetaData?: {
+    CreateTime: string;
+    LastUpdatedTime: string;
+  };
+}
+
+async function quickbooksFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with QuickBooks. Please connect your account.");
+  }
+
+  const realmId = getRealmId();
+  const url = `${QUICKBOOKS_BASE_URL}/company/${realmId}${endpoint}`;
+
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Accept": "application/json",
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `QuickBooks API error: ${response.status} ${error.Fault?.Error?.[0]?.Message || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function listInvoices(options?: {
+  customerId?: string;
+  maxResults?: number;
+}): Promise<QuickBooksInvoice[]> {
+  const maxResults = options?.maxResults || 100;
+  let query = `SELECT * FROM Invoice MAXRESULTS ${maxResults}`;
+
+  if (options?.customerId) {
+    query = `SELECT * FROM Invoice WHERE CustomerRef = '${options.customerId}' MAXRESULTS ${maxResults}`;
+  }
+
+  const response = await quickbooksFetch<QuickBooksResponse<QuickBooksInvoice>>(
+    `/query?query=${encodeURIComponent(query)}`,
+  );
+
+  return response.QueryResponse?.Invoice || [];
+}
+
+export async function getInvoice(invoiceId: string): Promise<QuickBooksInvoice> {
+  const response = await quickbooksFetch<QuickBooksResponse<QuickBooksInvoice>>(
+    `/invoice/${invoiceId}`,
+  );
+
+  if (!response.Invoice) {
+    throw new Error(`Invoice ${invoiceId} not found`);
+  }
+
+  return response.Invoice;
+}
+
+export async function createInvoice(options: {
+  customerId: string;
+  lineItems: Array<{
+    description?: string;
+    amount: number;
+    itemId?: string;
+    quantity?: number;
+    unitPrice?: number;
+  }>;
+  txnDate?: string;
+  dueDate?: string;
+  customerMemo?: string;
+}): Promise<QuickBooksInvoice> {
+  const lines = options.lineItems.map((item, index) => {
+    const line: Record<string, unknown> = {
+      LineNum: index + 1,
+      Amount: item.amount,
+      DetailType: "SalesItemLineDetail",
+    };
+
+    if (item.description) {
+      line.Description = item.description;
+    }
+
+    if (item.itemId) {
+      line.SalesItemLineDetail = {
+        ItemRef: {
+          value: item.itemId,
+        },
+        Qty: item.quantity || 1,
+        UnitPrice: item.unitPrice || item.amount,
+      };
+    }
+
+    return line;
+  });
+
+  const invoiceData: Record<string, unknown> = {
+    CustomerRef: {
+      value: options.customerId,
+    },
+    Line: lines,
+  };
+
+  if (options.txnDate) {
+    invoiceData.TxnDate = options.txnDate;
+  }
+
+  if (options.dueDate) {
+    invoiceData.DueDate = options.dueDate;
+  }
+
+  if (options.customerMemo) {
+    invoiceData.CustomerMemo = {
+      value: options.customerMemo,
+    };
+  }
+
+  const response = await quickbooksFetch<QuickBooksResponse<QuickBooksInvoice>>(
+    "/invoice",
+    {
+      method: "POST",
+      body: JSON.stringify(invoiceData),
+    },
+  );
+
+  if (!response.Invoice) {
+    throw new Error("Failed to create invoice");
+  }
+
+  return response.Invoice;
+}
+
+export async function listCustomers(options?: {
+  maxResults?: number;
+  active?: boolean;
+}): Promise<QuickBooksCustomer[]> {
+  const maxResults = options?.maxResults || 100;
+  let query = `SELECT * FROM Customer MAXRESULTS ${maxResults}`;
+
+  if (options?.active !== undefined) {
+    query = `SELECT * FROM Customer WHERE Active = ${options.active} MAXRESULTS ${maxResults}`;
+  }
+
+  const response = await quickbooksFetch<QuickBooksResponse<QuickBooksCustomer>>(
+    `/query?query=${encodeURIComponent(query)}`,
+  );
+
+  return response.QueryResponse?.Customer || [];
+}
+
+export async function getCustomer(customerId: string): Promise<QuickBooksCustomer> {
+  const response = await quickbooksFetch<QuickBooksResponse<QuickBooksCustomer>>(
+    `/customer/${customerId}`,
+  );
+
+  if (!response.Customer) {
+    throw new Error(`Customer ${customerId} not found`);
+  }
+
+  return response.Customer;
+}

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

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

package/dist/integrations/salesforce/connector.json

@@ -0,0 +1,104 @@
+{
+  "name": "salesforce",
+  "displayName": "Salesforce",
+  "icon": "salesforce.svg",
+  "description": "Manage accounts, contacts, opportunities, and leads in your Salesforce CRM",
+  "auth": {
+    "type": "oauth2",
+    "provider": "salesforce",
+    "authorizationUrl": "https://login.salesforce.com/services/oauth2/authorize",
+    "tokenUrl": "https://login.salesforce.com/services/oauth2/token",
+    "scopes": [
+      "api",
+      "refresh_token",
+      "offline_access"
+    ],
+    "callbackPath": "/api/auth/salesforce/callback",
+    "tokenAuthMethod": "request_body",
+    "requiredApis": [
+      {
+        "name": "Salesforce Connected App",
+        "enableUrl": "https://login.salesforce.com/"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "SALESFORCE_CLIENT_ID",
+      "description": "Salesforce OAuth Consumer Key (from your Connected App)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://help.salesforce.com/s/articleView?id=sf.connected_app_create.htm"
+    },
+    {
+      "name": "SALESFORCE_CLIENT_SECRET",
+      "description": "Salesforce OAuth Consumer Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://help.salesforce.com/s/articleView?id=sf.connected_app_create.htm"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-accounts",
+      "name": "List Accounts",
+      "description": "List accounts from your Salesforce CRM",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-account",
+      "name": "Get Account",
+      "description": "Get detailed information about a specific account",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-contacts",
+      "name": "List Contacts",
+      "description": "List contacts from your Salesforce CRM",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-opportunities",
+      "name": "List Opportunities",
+      "description": "List sales opportunities from your Salesforce CRM",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-lead",
+      "name": "Create Lead",
+      "description": "Create a new lead in Salesforce CRM",
+      "requiresWrite": true
+    }
+  ],
+  "prompts": [
+    {
+      "id": "find-accounts",
+      "title": "Find accounts",
+      "prompt": "Search for accounts in my Salesforce CRM and show me their key information.",
+      "category": "crm",
+      "icon": "search"
+    },
+    {
+      "id": "create-lead",
+      "title": "Create a lead",
+      "prompt": "Create a new lead in Salesforce CRM with the information I provide.",
+      "category": "crm",
+      "icon": "plus"
+    },
+    {
+      "id": "pipeline-summary",
+      "title": "Pipeline summary",
+      "prompt": "Show me a summary of my current sales opportunities and pipeline status.",
+      "category": "crm",
+      "icon": "chart"
+    },
+    {
+      "id": "contact-lookup",
+      "title": "Contact lookup",
+      "prompt": "Find and display information about specific contacts in my Salesforce CRM.",
+      "category": "crm",
+      "icon": "user"
+    }
+  ],
+  "suggestedWith": ["gmail", "slack", "calendar"]
+}

package/dist/integrations/salesforce/files/ai/tools/create-lead.ts

@@ -0,0 +1,101 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createLead, formatLeadName } from "../../lib/salesforce-client.ts";
+
+export default tool({
+  id: "create-lead",
+  description:
+    "Create a new lead in Salesforce CRM. LastName and Company are required, other fields are optional.",
+  inputSchema: z.object({
+    lastName: z.string().describe("Last name (required)"),
+    company: z.string().describe("Company name (required)"),
+    firstName: z.string().optional().describe("First name"),
+    email: z.string().email().optional().describe("Email address"),
+    phone: z.string().optional().describe("Phone number"),
+    mobilePhone: z.string().optional().describe("Mobile phone number"),
+    title: z.string().optional().describe("Job title"),
+    status: z.string().optional().describe(
+      'Lead status (e.g., "Open - Not Contacted", "Working - Contacted", "Closed - Converted")',
+    ),
+    leadSource: z.string().optional().describe(
+      'Lead source (e.g., "Web", "Phone Inquiry", "Partner Referral")',
+    ),
+    industry: z.string().optional().describe("Industry"),
+    street: z.string().optional().describe("Street address"),
+    city: z.string().optional().describe("City"),
+    state: z.string().optional().describe("State/Province"),
+    postalCode: z.string().optional().describe("Postal code"),
+    country: z.string().optional().describe("Country"),
+    website: z.string().optional().describe("Website URL"),
+    description: z.string().optional().describe("Description or notes about the lead"),
+    rating: z.string().optional().describe('Lead rating (e.g., "Hot", "Warm", "Cold")'),
+  }),
+  async execute({
+    lastName,
+    company,
+    firstName,
+    email,
+    phone,
+    mobilePhone,
+    title,
+    status,
+    leadSource,
+    industry,
+    street,
+    city,
+    state,
+    postalCode,
+    country,
+    website,
+    description,
+    rating,
+  }) {
+    const leadData: Record<string, any> = {
+      LastName: lastName,
+      Company: company,
+    };
+
+    if (firstName) leadData.FirstName = firstName;
+    if (email) leadData.Email = email;
+    if (phone) leadData.Phone = phone;
+    if (mobilePhone) leadData.MobilePhone = mobilePhone;
+    if (title) leadData.Title = title;
+    if (status) leadData.Status = status;
+    if (leadSource) leadData.LeadSource = leadSource;
+    if (industry) leadData.Industry = industry;
+    if (street) leadData.Street = street;
+    if (city) leadData.City = city;
+    if (state) leadData.State = state;
+    if (postalCode) leadData.PostalCode = postalCode;
+    if (country) leadData.Country = country;
+    if (website) leadData.Website = website;
+    if (description) leadData.Description = description;
+    if (rating) leadData.Rating = rating;
+
+    const result = await createLead(leadData);
+
+    if (!result.success) {
+      throw new Error(`Failed to create lead: ${JSON.stringify(result.errors)}`);
+    }
+
+    // Create a minimal lead object for formatting the name
+    const lead = {
+      FirstName: firstName,
+      LastName: lastName,
+      Email: email,
+    } as any;
+
+    return {
+      id: result.id,
+      name: formatLeadName(lead),
+      lastName,
+      firstName,
+      company,
+      email,
+      phone,
+      title,
+      status: status || "Open - Not Contacted",
+      message: `Successfully created lead: ${formatLeadName(lead)} at ${company}`,
+    };
+  },
+});

package/dist/integrations/salesforce/files/ai/tools/get-account.ts

@@ -0,0 +1,53 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatAddress, getAccount } from "../../lib/salesforce-client.ts";
+
+export default tool({
+  id: "get-account",
+  description:
+    "Get detailed information about a specific account in Salesforce CRM by their account ID.",
+  inputSchema: z.object({
+    accountId: z.string().describe("The Salesforce account ID (e.g., 001XXXXXXXXXXXXXXX)"),
+    fields: z.array(z.string()).optional().describe(
+      "Additional fields to retrieve (e.g., Description, Owner.Name, ParentId)",
+    ),
+  }),
+  async execute({ accountId, fields }) {
+    const account = await getAccount(accountId, fields);
+
+    const billingAddress = formatAddress(
+      account.BillingStreet,
+      account.BillingCity,
+      account.BillingState,
+      account.BillingPostalCode,
+      account.BillingCountry,
+    );
+
+    return {
+      id: account.Id,
+      name: account.Name,
+      type: account.Type,
+      industry: account.Industry,
+      website: account.Website,
+      phone: account.Phone,
+      billingAddress: billingAddress || undefined,
+      billingStreet: account.BillingStreet,
+      billingCity: account.BillingCity,
+      billingState: account.BillingState,
+      billingPostalCode: account.BillingPostalCode,
+      billingCountry: account.BillingCountry,
+      numberOfEmployees: account.NumberOfEmployees,
+      annualRevenue: account.AnnualRevenue,
+      description: account.Description,
+      createdDate: account.CreatedDate,
+      lastModifiedDate: account.LastModifiedDate,
+      additionalFields: fields
+        ? Object.fromEntries(
+          fields
+            .filter((field) => account[field] !== undefined)
+            .map((field) => [field, account[field]]),
+        )
+        : undefined,
+    };
+  },
+});

package/dist/integrations/salesforce/files/ai/tools/list-accounts.ts

@@ -0,0 +1,50 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listAccounts } from "../../lib/salesforce-client.ts";
+
+export default tool({
+  id: "list-accounts",
+  description:
+    "List accounts from your Salesforce CRM. Returns account information including name, type, industry, website, and billing details.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(100).default(10).describe("Maximum number of accounts to return"),
+    offset: z.number().min(0).default(0).describe("Number of records to skip for pagination"),
+    fields: z.array(z.string()).optional().describe(
+      "Additional fields to retrieve (e.g., Description, Owner.Name, ParentId)",
+    ),
+  }),
+  async execute({ limit, offset, fields }) {
+    const response = await listAccounts({
+      limit,
+      offset,
+      fields,
+    });
+
+    return {
+      accounts: response.records.map((account) => ({
+        id: account.Id,
+        name: account.Name,
+        type: account.Type,
+        industry: account.Industry,
+        website: account.Website,
+        phone: account.Phone,
+        billingCity: account.BillingCity,
+        billingState: account.BillingState,
+        billingCountry: account.BillingCountry,
+        numberOfEmployees: account.NumberOfEmployees,
+        annualRevenue: account.AnnualRevenue,
+        createdDate: account.CreatedDate,
+        lastModifiedDate: account.LastModifiedDate,
+        additionalFields: fields
+          ? Object.fromEntries(
+            fields
+              .filter((field) => account[field] !== undefined)
+              .map((field) => [field, account[field]]),
+          )
+          : undefined,
+      })),
+      totalSize: response.totalSize,
+      hasMore: !response.done,
+    };
+  },
+});

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

@@ -0,0 +1,54 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatContactName, listContacts } from "../../lib/salesforce-client.ts";
+
+export default tool({
+  id: "list-contacts",
+  description:
+    "List contacts from your Salesforce CRM. Returns contact information including name, email, phone, title, and account association.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(100).default(10).describe("Maximum number of contacts to return"),
+    offset: z.number().min(0).default(0).describe("Number of records to skip for pagination"),
+    accountId: z.string().optional().describe("Filter contacts by Account ID"),
+    fields: z.array(z.string()).optional().describe(
+      "Additional fields to retrieve (e.g., Account.Name, Owner.Name, LeadSource)",
+    ),
+  }),
+  async execute({ limit, offset, accountId, fields }) {
+    const response = await listContacts({
+      limit,
+      offset,
+      accountId,
+      fields,
+    });
+
+    return {
+      contacts: response.records.map((contact) => ({
+        id: contact.Id,
+        name: formatContactName(contact),
+        firstName: contact.FirstName,
+        lastName: contact.LastName,
+        email: contact.Email,
+        phone: contact.Phone,
+        mobilePhone: contact.MobilePhone,
+        title: contact.Title,
+        department: contact.Department,
+        accountId: contact.AccountId,
+        mailingCity: contact.MailingCity,
+        mailingState: contact.MailingState,
+        mailingCountry: contact.MailingCountry,
+        createdDate: contact.CreatedDate,
+        lastModifiedDate: contact.LastModifiedDate,
+        additionalFields: fields
+          ? Object.fromEntries(
+            fields
+              .filter((field) => contact[field] !== undefined)
+              .map((field) => [field, contact[field]]),
+          )
+          : undefined,
+      })),
+      totalSize: response.totalSize,
+      hasMore: !response.done,
+    };
+  },
+});

package/dist/integrations/salesforce/files/ai/tools/list-opportunities.ts

@@ -0,0 +1,55 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listOpportunities } from "../../lib/salesforce-client.ts";
+
+export default tool({
+  id: "list-opportunities",
+  description:
+    "List sales opportunities from your Salesforce CRM. Returns opportunity information including name, amount, stage, close date, and account association.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(100).default(10).describe(
+      "Maximum number of opportunities to return",
+    ),
+    offset: z.number().min(0).default(0).describe("Number of records to skip for pagination"),
+    accountId: z.string().optional().describe("Filter opportunities by Account ID"),
+    fields: z.array(z.string()).optional().describe(
+      "Additional fields to retrieve (e.g., Account.Name, Owner.Name, Description)",
+    ),
+  }),
+  async execute({ limit, offset, accountId, fields }) {
+    const response = await listOpportunities({
+      limit,
+      offset,
+      accountId,
+      fields,
+    });
+
+    return {
+      opportunities: response.records.map((opportunity) => ({
+        id: opportunity.Id,
+        name: opportunity.Name,
+        accountId: opportunity.AccountId,
+        amount: opportunity.Amount,
+        stageName: opportunity.StageName,
+        probability: opportunity.Probability,
+        closeDate: opportunity.CloseDate,
+        type: opportunity.Type,
+        leadSource: opportunity.LeadSource,
+        isClosed: opportunity.IsClosed,
+        isWon: opportunity.IsWon,
+        forecastCategory: opportunity.ForecastCategory,
+        createdDate: opportunity.CreatedDate,
+        lastModifiedDate: opportunity.LastModifiedDate,
+        additionalFields: fields
+          ? Object.fromEntries(
+            fields
+              .filter((field) => opportunity[field] !== undefined)
+              .map((field) => [field, opportunity[field]]),
+          )
+          : undefined,
+      })),
+      totalSize: response.totalSize,
+      hasMore: !response.done,
+    };
+  },
+});

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

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