veryfront 0.0.49 → 0.0.50

package/dist/integrations/xero/files/ai/tools/list-invoices.ts

@@ -0,0 +1,54 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listInvoices } from "../../lib/xero-client.ts";
+
+export default tool({
+  id: "list-invoices",
+  description:
+    "List invoices from Xero. Can filter by status, type, or contact.",
+  inputSchema: z.object({
+    status: z
+      .enum(["DRAFT", "SUBMITTED", "AUTHORISED", "PAID", "VOIDED"])
+      .optional()
+      .describe("Filter by invoice status"),
+    type: z
+      .enum(["ACCREC", "ACCPAY"])
+      .optional()
+      .describe("Filter by invoice type (ACCREC = sales invoice, ACCPAY = bill)"),
+    contactId: z
+      .string()
+      .optional()
+      .describe("Filter by contact ID"),
+    limit: z
+      .number()
+      .min(1)
+      .max(100)
+      .default(20)
+      .describe("Maximum number of invoices to return"),
+  }),
+  async execute({ status, type, contactId, limit }) {
+    const invoices = await listInvoices({
+      status,
+      type,
+      contactId,
+      limit,
+    });
+
+    return invoices.map((invoice) => ({
+      invoiceId: invoice.InvoiceID,
+      invoiceNumber: invoice.InvoiceNumber,
+      type: invoice.Type,
+      status: invoice.Status,
+      contact: invoice.Contact.Name,
+      date: invoice.Date,
+      dueDate: invoice.DueDate,
+      subTotal: invoice.SubTotal,
+      totalTax: invoice.TotalTax,
+      total: invoice.Total,
+      amountDue: invoice.AmountDue,
+      amountPaid: invoice.AmountPaid,
+      currencyCode: invoice.CurrencyCode,
+      reference: invoice.Reference,
+    }));
+  },
+});

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

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

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

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

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

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

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

@@ -0,0 +1,292 @@
+import { getAccessToken } from "./token-store.ts";
+
+const XERO_BASE_URL = "https://api.xero.com/api.xro/2.0";
+
+interface XeroResponse<T> {
+  Id: string;
+  Status: string;
+  ProviderName: string;
+  DateTimeUTC: string;
+  [key: string]: T | string;
+}
+
+interface XeroInvoice {
+  InvoiceID: string;
+  InvoiceNumber: string;
+  Type: "ACCREC" | "ACCPAY";
+  Status: string;
+  LineAmountTypes: string;
+  Contact: {
+    ContactID: string;
+    Name: string;
+  };
+  LineItems: Array<{
+    LineItemID?: string;
+    Description: string;
+    Quantity: number;
+    UnitAmount: number;
+    AccountCode?: string;
+    TaxType?: string;
+    LineAmount: number;
+  }>;
+  Date: string;
+  DueDate: string;
+  SubTotal: number;
+  TotalTax: number;
+  Total: number;
+  AmountDue: number;
+  AmountPaid: number;
+  CurrencyCode: string;
+  Reference?: string;
+  UpdatedDateUTC: string;
+}
+
+interface XeroContact {
+  ContactID: string;
+  ContactNumber?: string;
+  Name: string;
+  FirstName?: string;
+  LastName?: string;
+  EmailAddress?: string;
+  Addresses?: Array<{
+    AddressType: string;
+    City?: string;
+    Region?: string;
+    PostalCode?: string;
+    Country?: string;
+    AttentionTo?: string;
+  }>;
+  Phones?: Array<{
+    PhoneType: string;
+    PhoneNumber?: string;
+    PhoneAreaCode?: string;
+    PhoneCountryCode?: string;
+  }>;
+  UpdatedDateUTC: string;
+  IsSupplier: boolean;
+  IsCustomer: boolean;
+}
+
+interface XeroTenant {
+  tenantId: string;
+  tenantType: string;
+  tenantName: string;
+}
+
+async function xeroFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Xero. Please connect your account.");
+  }
+
+  // Get the tenant ID (organization)
+  const tenantsResponse = await fetch("https://api.xero.com/connections", {
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (!tenantsResponse.ok) {
+    throw new Error(`Failed to get Xero tenants: ${tenantsResponse.status}`);
+  }
+
+  const tenants = (await tenantsResponse.json()) as XeroTenant[];
+  if (tenants.length === 0) {
+    throw new Error("No Xero organizations found. Please connect to a Xero organization.");
+  }
+
+  const tenantId = tenants[0].tenantId;
+
+  const response = await fetch(`${XERO_BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "xero-tenant-id": tenantId,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Xero API error: ${response.status} ${error.Message || error.Detail || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function listInvoices(options?: {
+  status?: "DRAFT" | "SUBMITTED" | "AUTHORISED" | "PAID" | "VOIDED";
+  type?: "ACCREC" | "ACCPAY";
+  contactId?: string;
+  limit?: number;
+}): Promise<XeroInvoice[]> {
+  const params = new URLSearchParams();
+
+  let where: string[] = [];
+  if (options?.status) {
+    where.push(`Status == "${options.status}"`);
+  }
+  if (options?.type) {
+    where.push(`Type == "${options.type}"`);
+  }
+  if (options?.contactId) {
+    where.push(`Contact.ContactID == Guid("${options.contactId}")`);
+  }
+
+  if (where.length > 0) {
+    params.set("where", where.join(" AND "));
+  }
+
+  if (options?.limit) {
+    params.set("page", "1");
+  }
+
+  const queryString = params.toString();
+  const endpoint = `/Invoices${queryString ? `?${queryString}` : ""}`;
+
+  const response = await xeroFetch<XeroResponse<{ Invoices: XeroInvoice[] }>>(endpoint);
+  const invoices = (response as unknown as { Invoices: XeroInvoice[] }).Invoices || [];
+
+  return options?.limit ? invoices.slice(0, options.limit) : invoices;
+}
+
+export async function getInvoice(invoiceId: string): Promise<XeroInvoice> {
+  const response = await xeroFetch<XeroResponse<{ Invoices: XeroInvoice[] }>>(
+    `/Invoices/${invoiceId}`,
+  );
+  const invoices = (response as unknown as { Invoices: XeroInvoice[] }).Invoices;
+
+  if (!invoices || invoices.length === 0) {
+    throw new Error(`Invoice not found: ${invoiceId}`);
+  }
+
+  return invoices[0];
+}
+
+export async function createInvoice(options: {
+  contactId: string;
+  type: "ACCREC" | "ACCPAY";
+  date: string;
+  dueDate: string;
+  lineItems: Array<{
+    description: string;
+    quantity: number;
+    unitAmount: number;
+    accountCode?: string;
+    taxType?: string;
+  }>;
+  reference?: string;
+  status?: "DRAFT" | "SUBMITTED" | "AUTHORISED";
+}): Promise<XeroInvoice> {
+  const invoice = {
+    Type: options.type,
+    Contact: {
+      ContactID: options.contactId,
+    },
+    Date: options.date,
+    DueDate: options.dueDate,
+    LineItems: options.lineItems.map((item) => ({
+      Description: item.description,
+      Quantity: item.quantity,
+      UnitAmount: item.unitAmount,
+      AccountCode: item.accountCode,
+      TaxType: item.taxType || "NONE",
+    })),
+    Reference: options.reference,
+    Status: options.status || "DRAFT",
+    LineAmountTypes: "Exclusive",
+  };
+
+  const response = await xeroFetch<XeroResponse<{ Invoices: XeroInvoice[] }>>(
+    "/Invoices",
+    {
+      method: "POST",
+      body: JSON.stringify({ Invoices: [invoice] }),
+    },
+  );
+
+  const invoices = (response as unknown as { Invoices: XeroInvoice[] }).Invoices;
+  if (!invoices || invoices.length === 0) {
+    throw new Error("Failed to create invoice");
+  }
+
+  return invoices[0];
+}
+
+export async function listContacts(options?: {
+  isCustomer?: boolean;
+  isSupplier?: boolean;
+  limit?: number;
+}): Promise<XeroContact[]> {
+  const params = new URLSearchParams();
+
+  let where: string[] = [];
+  if (options?.isCustomer !== undefined) {
+    where.push(`IsCustomer == ${options.isCustomer}`);
+  }
+  if (options?.isSupplier !== undefined) {
+    where.push(`IsSupplier == ${options.isSupplier}`);
+  }
+
+  if (where.length > 0) {
+    params.set("where", where.join(" AND "));
+  }
+
+  const queryString = params.toString();
+  const endpoint = `/Contacts${queryString ? `?${queryString}` : ""}`;
+
+  const response = await xeroFetch<XeroResponse<{ Contacts: XeroContact[] }>>(endpoint);
+  const contacts = (response as unknown as { Contacts: XeroContact[] }).Contacts || [];
+
+  return options?.limit ? contacts.slice(0, options.limit) : contacts;
+}
+
+export async function getContact(contactId: string): Promise<XeroContact> {
+  const response = await xeroFetch<XeroResponse<{ Contacts: XeroContact[] }>>(
+    `/Contacts/${contactId}`,
+  );
+  const contacts = (response as unknown as { Contacts: XeroContact[] }).Contacts;
+
+  if (!contacts || contacts.length === 0) {
+    throw new Error(`Contact not found: ${contactId}`);
+  }
+
+  return contacts[0];
+}
+
+export async function getCurrentUser(): Promise<{
+  userId: string;
+  userName: string;
+  email: string;
+}> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Xero. Please connect your account.");
+  }
+
+  const response = await fetch("https://api.xero.com/api.xro/2.0/Organisation", {
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to get user info: ${response.status}`);
+  }
+
+  const data = (await response.json()) as { Organisations: Array<{ Name: string }> };
+  return {
+    userId: "current-user",
+    userName: data.Organisations[0]?.Name || "Xero User",
+    email: "user@xero.com",
+  };
+}

package/dist/integrations/zendesk/connector.json

@@ -0,0 +1,61 @@
+{
+  "name": "zendesk",
+  "displayName": "Zendesk",
+  "icon": "zendesk.svg",
+  "description": "Manage support tickets, users, and help center content",
+  "category": "support",
+  "auth": {
+    "type": "oauth2",
+    "provider": "zendesk",
+    "scopes": ["read", "write"],
+    "callbackPath": "/api/auth/zendesk/callback"
+  },
+  "tools": [
+    {
+      "id": "list-tickets",
+      "name": "List Tickets",
+      "description": "List Zendesk tickets with optional filters"
+    },
+    {
+      "id": "get-ticket",
+      "name": "Get Ticket",
+      "description": "Get details of a specific ticket"
+    },
+    {
+      "id": "create-ticket",
+      "name": "Create Ticket",
+      "description": "Create a new ticket in Zendesk"
+    },
+    {
+      "id": "search-tickets",
+      "name": "Search Tickets",
+      "description": "Search tickets using Zendesk query syntax"
+    }
+  ],
+  "prompts": [
+    {
+      "id": "check-ticket-status",
+      "title": "Check ticket status",
+      "prompt": "Check the status of my recent Zendesk tickets and summarize any that need attention.",
+      "category": "productivity"
+    },
+    {
+      "id": "create-support-ticket",
+      "title": "Create support ticket",
+      "prompt": "Help me create a new support ticket in Zendesk with the appropriate priority and tags.",
+      "category": "productivity"
+    },
+    {
+      "id": "search-tickets",
+      "title": "Search tickets",
+      "prompt": "Search Zendesk tickets for specific issues or customer inquiries.",
+      "category": "research"
+    }
+  ],
+  "envVars": [
+    "ZENDESK_SUBDOMAIN",
+    "ZENDESK_CLIENT_ID",
+    "ZENDESK_CLIENT_SECRET"
+  ],
+  "suggestedWith": ["slack", "intercom"]
+}

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

@@ -0,0 +1,5 @@
+# Zendesk OAuth Configuration
+# Get these from your Zendesk Admin Center: Apps and integrations > APIs > Zendesk API > OAuth Clients
+ZENDESK_SUBDOMAIN=your-subdomain
+ZENDESK_CLIENT_ID=your_client_id
+ZENDESK_CLIENT_SECRET=your_client_secret

package/dist/integrations/zendesk/files/ai/tools/create-ticket.ts

@@ -0,0 +1,82 @@
+/**
+ * Create Zendesk Ticket Tool
+ */
+
+import { z } from "zod";
+import { defineTool } from "veryfront/ai";
+import { getZendeskClient } from "../../lib/zendesk-client.ts";
+import { isZendeskConnected } from "../../lib/token-store.ts";
+
+export default defineTool({
+  id: "zendesk-create-ticket",
+  description: "Create a new ticket in Zendesk",
+  inputSchema: z.object({
+    subject: z.string().describe("Subject/title of the ticket"),
+    body: z.string().describe("Description/body content of the ticket"),
+    priority: z.enum(["urgent", "high", "normal", "low"]).optional()
+      .describe("Priority level of the ticket"),
+    type: z.enum(["problem", "incident", "question", "task"]).optional()
+      .describe("Type of ticket"),
+    tags: z.array(z.string()).optional().describe("Tags to add to the ticket"),
+    assigneeId: z.number().optional().describe("User ID to assign the ticket to"),
+    requesterName: z.string().optional().describe("Name of the requester (if creating on behalf)"),
+    requesterEmail: z.string().optional().describe(
+      "Email of the requester (if creating on behalf)",
+    ),
+  }),
+  async execute(input) {
+    const connected = await isZendeskConnected();
+    if (!connected) {
+      return {
+        error: "Zendesk not connected",
+        action: "Please connect Zendesk via /api/auth/zendesk",
+      };
+    }
+
+    try {
+      const client = getZendeskClient();
+
+      const ticketData: {
+        subject: string;
+        comment: { body: string };
+        requester?: { name: string; email: string };
+        priority?: "urgent" | "high" | "normal" | "low";
+        type?: "problem" | "incident" | "question" | "task";
+        tags?: string[];
+        assignee_id?: number;
+      } = {
+        subject: input.subject,
+        comment: { body: input.body },
+      };
+
+      if (input.priority) ticketData.priority = input.priority;
+      if (input.type) ticketData.type = input.type;
+      if (input.tags) ticketData.tags = input.tags;
+      if (input.assigneeId) ticketData.assignee_id = input.assigneeId;
+
+      if (input.requesterName && input.requesterEmail) {
+        ticketData.requester = {
+          name: input.requesterName,
+          email: input.requesterEmail,
+        };
+      }
+
+      const ticket = await client.createTicket(ticketData);
+
+      return {
+        success: true,
+        id: ticket.id,
+        url: ticket.url,
+        subject: ticket.subject,
+        status: ticket.status,
+        priority: ticket.priority,
+        type: ticket.type,
+        message: `Ticket #${ticket.id} created successfully`,
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : "Failed to create ticket",
+      };
+    }
+  },
+});

package/dist/integrations/zendesk/files/ai/tools/get-ticket.ts

@@ -0,0 +1,53 @@
+/**
+ * Get Zendesk Ticket Tool
+ */
+
+import { z } from "zod";
+import { defineTool } from "veryfront/ai";
+import { getZendeskClient } from "../../lib/zendesk-client.ts";
+import { isZendeskConnected } from "../../lib/token-store.ts";
+
+export default defineTool({
+  id: "zendesk-get-ticket",
+  description: "Get detailed information about a specific Zendesk ticket by ID",
+  inputSchema: z.object({
+    ticketId: z.number().describe("The ticket ID to retrieve"),
+  }),
+  async execute(input) {
+    const connected = await isZendeskConnected();
+    if (!connected) {
+      return {
+        error: "Zendesk not connected",
+        action: "Please connect Zendesk via /api/auth/zendesk",
+      };
+    }
+
+    try {
+      const client = getZendeskClient();
+      const ticket = await client.getTicket(input.ticketId);
+
+      return {
+        ticket: {
+          id: ticket.id,
+          url: ticket.url,
+          subject: ticket.subject,
+          description: ticket.description,
+          status: ticket.status,
+          priority: ticket.priority,
+          type: ticket.type,
+          requester_id: ticket.requester_id,
+          submitter_id: ticket.submitter_id,
+          assignee_id: ticket.assignee_id,
+          tags: ticket.tags,
+          created_at: ticket.created_at,
+          updated_at: ticket.updated_at,
+          due_at: ticket.due_at,
+        },
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : "Failed to get ticket",
+      };
+    }
+  },
+});

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

@@ -0,0 +1,60 @@
+/**
+ * List Zendesk Tickets Tool
+ */
+
+import { z } from "zod";
+import { defineTool } from "veryfront/ai";
+import { getZendeskClient } from "../../lib/zendesk-client.ts";
+import { isZendeskConnected } from "../../lib/token-store.ts";
+
+export default defineTool({
+  id: "zendesk-list-tickets",
+  description: "List tickets from Zendesk with optional filters for status, priority, or assignee",
+  inputSchema: z.object({
+    limit: z.number().optional().describe("Maximum number of tickets to return (default: 20)"),
+    status: z.enum(["new", "open", "pending", "hold", "solved", "closed"]).optional()
+      .describe("Filter by ticket status"),
+    priority: z.enum(["urgent", "high", "normal", "low"]).optional()
+      .describe("Filter by priority level"),
+    assigneeId: z.number().optional().describe("Filter by assignee user ID"),
+  }),
+  async execute(input) {
+    const connected = await isZendeskConnected();
+    if (!connected) {
+      return {
+        error: "Zendesk not connected",
+        action: "Please connect Zendesk via /api/auth/zendesk",
+      };
+    }
+
+    try {
+      const client = getZendeskClient();
+      const tickets = await client.listTickets({
+        limit: input.limit,
+        status: input.status,
+        priority: input.priority,
+        assigneeId: input.assigneeId,
+      });
+
+      return {
+        count: tickets.length,
+        tickets: tickets.map((ticket) => ({
+          id: ticket.id,
+          subject: ticket.subject,
+          status: ticket.status,
+          priority: ticket.priority,
+          type: ticket.type,
+          requester_id: ticket.requester_id,
+          assignee_id: ticket.assignee_id,
+          tags: ticket.tags,
+          created_at: ticket.created_at,
+          updated_at: ticket.updated_at,
+        })),
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : "Failed to list tickets",
+      };
+    }
+  },
+});

package/dist/integrations/zendesk/files/ai/tools/search-tickets.ts

@@ -0,0 +1,56 @@
+/**
+ * Search Zendesk Tickets Tool
+ */
+
+import { z } from "zod";
+import { defineTool } from "veryfront/ai";
+import { getZendeskClient } from "../../lib/zendesk-client.ts";
+import { isZendeskConnected } from "../../lib/token-store.ts";
+
+export default defineTool({
+  id: "zendesk-search-tickets",
+  description:
+    "Search tickets using Zendesk query syntax. Examples: 'status:open priority:urgent', 'subject:bug', 'tags:billing'",
+  inputSchema: z.object({
+    query: z.string().describe(
+      "Search query using Zendesk syntax (e.g., 'status:open priority:urgent', 'subject:refund', 'tags:billing')",
+    ),
+    limit: z.number().optional().describe("Maximum number of results to return (default: 20)"),
+  }),
+  async execute(input) {
+    const connected = await isZendeskConnected();
+    if (!connected) {
+      return {
+        error: "Zendesk not connected",
+        action: "Please connect Zendesk via /api/auth/zendesk",
+      };
+    }
+
+    try {
+      const client = getZendeskClient();
+      const tickets = await client.searchTickets(input.query, input.limit);
+
+      return {
+        count: tickets.length,
+        query: input.query,
+        tickets: tickets.map((ticket) => ({
+          id: ticket.id,
+          subject: ticket.subject,
+          description: ticket.description,
+          status: ticket.status,
+          priority: ticket.priority,
+          type: ticket.type,
+          requester_id: ticket.requester_id,
+          assignee_id: ticket.assignee_id,
+          tags: ticket.tags,
+          created_at: ticket.created_at,
+          updated_at: ticket.updated_at,
+        })),
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : "Failed to search tickets",
+      };
+    }
+  },
+});