veryfront 0.0.49 → 0.0.51

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

@@ -0,0 +1,279 @@
+import { getAccessToken } from "./token-store.ts";
+
+const WEBEX_BASE_URL = "https://webexapis.com/v1";
+
+interface WebexMeeting {
+  id: string;
+  title: string;
+  agenda?: string;
+  start: string;
+  end: string;
+  timezone: string;
+  hostEmail: string;
+  hostDisplayName: string;
+  webLink: string;
+  sipAddress?: string;
+  meetingNumber?: string;
+  state: string;
+  enabledAutoRecordMeeting?: boolean;
+  allowAnyUserToBeCoHost?: boolean;
+}
+
+interface WebexRoom {
+  id: string;
+  title: string;
+  type: "direct" | "group";
+  isLocked: boolean;
+  lastActivity: string;
+  creatorId: string;
+  created: string;
+}
+
+interface WebexMessage {
+  id: string;
+  roomId: string;
+  roomType: string;
+  text?: string;
+  markdown?: string;
+  personId: string;
+  personEmail: string;
+  created: string;
+}
+
+interface WebexPerson {
+  id: string;
+  emails: string[];
+  displayName: string;
+  firstName?: string;
+  lastName?: string;
+  avatar?: string;
+  orgId: string;
+  created: string;
+  lastActivity?: string;
+  status?: string;
+  type: string;
+}
+
+async function webexFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Webex. Please connect your account.");
+  }
+
+  const response = await fetch(`${WEBEX_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(
+      `Webex API error: ${response.status} ${error.message || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function getMe(): Promise<WebexPerson> {
+  return webexFetch<WebexPerson>("/people/me");
+}
+
+/**
+ * List meetings for the authenticated user
+ */
+export async function listMeetings(options?: {
+  max?: number;
+  from?: string;
+  to?: string;
+  meetingType?: "meeting" | "webinar" | "personalRoomMeeting";
+  state?: "active" | "scheduled" | "ended" | "missed" | "inProgress";
+}): Promise<WebexMeeting[]> {
+  const params = new URLSearchParams();
+
+  if (options?.max) params.set("max", options.max.toString());
+  if (options?.from) params.set("from", options.from);
+  if (options?.to) params.set("to", options.to);
+  if (options?.meetingType) params.set("meetingType", options.meetingType);
+  if (options?.state) params.set("state", options.state);
+
+  const response = await webexFetch<{ items: WebexMeeting[] }>(
+    `/meetings?${params}`,
+  );
+  return response.items || [];
+}
+
+/**
+ * Get details of a specific meeting
+ */
+export async function getMeeting(meetingId: string): Promise<WebexMeeting> {
+  return webexFetch<WebexMeeting>(`/meetings/${meetingId}`);
+}
+
+/**
+ * Create a new Webex meeting
+ */
+export async function createMeeting(options: {
+  title: string;
+  agenda?: string;
+  start: string;
+  end: string;
+  timezone?: string;
+  enabledAutoRecordMeeting?: boolean;
+  allowAnyUserToBeCoHost?: boolean;
+  invitees?: Array<{ email: string; displayName?: string; coHost?: boolean }>;
+}): Promise<WebexMeeting> {
+  const body: Record<string, unknown> = {
+    title: options.title,
+    start: options.start,
+    end: options.end,
+    timezone: options.timezone || "UTC",
+  };
+
+  if (options.agenda) body.agenda = options.agenda;
+  if (options.enabledAutoRecordMeeting !== undefined) {
+    body.enabledAutoRecordMeeting = options.enabledAutoRecordMeeting;
+  }
+  if (options.allowAnyUserToBeCoHost !== undefined) {
+    body.allowAnyUserToBeCoHost = options.allowAnyUserToBeCoHost;
+  }
+  if (options.invitees && options.invitees.length > 0) {
+    body.invitees = options.invitees;
+  }
+
+  return webexFetch<WebexMeeting>("/meetings", {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+}
+
+/**
+ * Update an existing meeting
+ */
+export async function updateMeeting(
+  meetingId: string,
+  updates: {
+    title?: string;
+    agenda?: string;
+    start?: string;
+    end?: string;
+    timezone?: string;
+    enabledAutoRecordMeeting?: boolean;
+  },
+): Promise<WebexMeeting> {
+  return webexFetch<WebexMeeting>(`/meetings/${meetingId}`, {
+    method: "PATCH",
+    body: JSON.stringify(updates),
+  });
+}
+
+/**
+ * Delete a meeting
+ */
+export async function deleteMeeting(meetingId: string): Promise<void> {
+  await webexFetch<void>(`/meetings/${meetingId}`, {
+    method: "DELETE",
+  });
+}
+
+/**
+ * List Webex rooms (spaces)
+ */
+export async function listRooms(options?: {
+  max?: number;
+  type?: "direct" | "group";
+  sortBy?: "id" | "lastactivity" | "created";
+}): Promise<WebexRoom[]> {
+  const params = new URLSearchParams();
+
+  if (options?.max) params.set("max", options.max.toString());
+  if (options?.type) params.set("type", options.type);
+  if (options?.sortBy) params.set("sortBy", options.sortBy);
+
+  const response = await webexFetch<{ items: WebexRoom[] }>(
+    `/rooms?${params}`,
+  );
+  return response.items || [];
+}
+
+/**
+ * Get details of a specific room
+ */
+export async function getRoom(roomId: string): Promise<WebexRoom> {
+  return webexFetch<WebexRoom>(`/rooms/${roomId}`);
+}
+
+/**
+ * Create a new room
+ */
+export async function createRoom(options: {
+  title: string;
+  teamId?: string;
+}): Promise<WebexRoom> {
+  return webexFetch<WebexRoom>("/rooms", {
+    method: "POST",
+    body: JSON.stringify(options),
+  });
+}
+
+/**
+ * Send a message to a Webex room
+ */
+export async function sendMessage(options: {
+  roomId?: string;
+  toPersonId?: string;
+  toPersonEmail?: string;
+  text?: string;
+  markdown?: string;
+  files?: string[];
+}): Promise<WebexMessage> {
+  if (!options.roomId && !options.toPersonId && !options.toPersonEmail) {
+    throw new Error("Must specify roomId, toPersonId, or toPersonEmail");
+  }
+
+  if (!options.text && !options.markdown && !options.files) {
+    throw new Error("Must specify text, markdown, or files");
+  }
+
+  return webexFetch<WebexMessage>("/messages", {
+    method: "POST",
+    body: JSON.stringify(options),
+  });
+}
+
+/**
+ * List messages in a room
+ */
+export async function listMessages(options: {
+  roomId: string;
+  max?: number;
+  before?: string;
+  beforeMessage?: string;
+}): Promise<WebexMessage[]> {
+  const params = new URLSearchParams({ roomId: options.roomId });
+
+  if (options.max) params.set("max", options.max.toString());
+  if (options.before) params.set("before", options.before);
+  if (options.beforeMessage) params.set("beforeMessage", options.beforeMessage);
+
+  const response = await webexFetch<{ items: WebexMessage[] }>(
+    `/messages?${params}`,
+  );
+  return response.items || [];
+}
+
+/**
+ * Delete a message
+ */
+export async function deleteMessage(messageId: string): Promise<void> {
+  await webexFetch<void>(`/messages/${messageId}`, {
+    method: "DELETE",
+  });
+}

package/dist/integrations/xero/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "xero",
+  "displayName": "Xero",
+  "icon": "xero.svg",
+  "description": "Manage invoices, contacts, and accounting data in Xero",
+  "auth": {
+    "type": "oauth2",
+    "provider": "xero",
+    "authorizationUrl": "https://login.xero.com/identity/connect/authorize",
+    "tokenUrl": "https://identity.xero.com/connect/token",
+    "scopes": ["openid", "profile", "email", "accounting.transactions", "offline_access"],
+    "callbackPath": "/api/auth/xero/callback",
+    "requiredApis": [
+      {
+        "name": "Xero Developer Portal",
+        "enableUrl": "https://developer.xero.com/app/manage"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "XERO_CLIENT_ID",
+      "description": "Xero OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developer.xero.com/documentation/guides/oauth2/overview"
+    },
+    {
+      "name": "XERO_CLIENT_SECRET",
+      "description": "Xero OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developer.xero.com/documentation/guides/oauth2/overview"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-invoices",
+      "name": "List Invoices",
+      "description": "List invoices from Xero",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-invoice",
+      "name": "Get Invoice",
+      "description": "Get details of a specific invoice",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-invoice",
+      "name": "Create Invoice",
+      "description": "Create a new invoice in Xero",
+      "requiresWrite": true
+    },
+    {
+      "id": "list-contacts",
+      "name": "List Contacts",
+      "description": "List contacts from Xero",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-contact",
+      "name": "Get Contact",
+      "description": "Get details of a specific contact",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "recent-invoices",
+      "title": "Show recent invoices",
+      "prompt": "List the most recent invoices from Xero with their status and amounts.",
+      "category": "accounting",
+      "icon": "receipt"
+    },
+    {
+      "id": "create-invoice",
+      "title": "Create an invoice",
+      "prompt": "Create a new invoice in Xero with line items and contact details.",
+      "category": "accounting",
+      "icon": "plus"
+    }
+  ],
+  "suggestedWith": ["quickbooks", "stripe", "hubspot"]
+}

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

@@ -0,0 +1,4 @@
+# Xero OAuth Configuration
+# Get your credentials from https://developer.xero.com/app/manage
+XERO_CLIENT_ID=your-client-id
+XERO_CLIENT_SECRET=your-client-secret

package/dist/integrations/xero/files/ai/tools/create-invoice.ts

@@ -0,0 +1,65 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createInvoice } from "../../lib/xero-client.ts";
+
+export default tool({
+  id: "create-invoice",
+  description: "Create a new invoice in Xero.",
+  inputSchema: z.object({
+    contactId: z.string().describe("The ID of the contact for the invoice"),
+    type: z
+      .enum(["ACCREC", "ACCPAY"])
+      .describe("Invoice type (ACCREC = sales invoice, ACCPAY = bill)"),
+    date: z
+      .string()
+      .describe("Invoice date in YYYY-MM-DD format"),
+    dueDate: z
+      .string()
+      .describe("Due date in YYYY-MM-DD format"),
+    lineItems: z
+      .array(
+        z.object({
+          description: z.string().describe("Line item description"),
+          quantity: z.number().describe("Quantity"),
+          unitAmount: z.number().describe("Unit price/amount"),
+          accountCode: z.string().optional().describe("Account code"),
+          taxType: z.string().optional().describe("Tax type (e.g., 'NONE', 'OUTPUT2', 'INPUT2')"),
+        }),
+      )
+      .describe("Line items for the invoice"),
+    reference: z
+      .string()
+      .optional()
+      .describe("Optional reference number"),
+    status: z
+      .enum(["DRAFT", "SUBMITTED", "AUTHORISED"])
+      .optional()
+      .describe("Invoice status (defaults to DRAFT)"),
+  }),
+  async execute({ contactId, type, date, dueDate, lineItems, reference, status }) {
+    const invoice = await createInvoice({
+      contactId,
+      type,
+      date,
+      dueDate,
+      lineItems,
+      reference,
+      status,
+    });
+
+    return {
+      success: true,
+      invoice: {
+        invoiceId: invoice.InvoiceID,
+        invoiceNumber: invoice.InvoiceNumber,
+        type: invoice.Type,
+        status: invoice.Status,
+        contact: invoice.Contact.Name,
+        date: invoice.Date,
+        dueDate: invoice.DueDate,
+        total: invoice.Total,
+        amountDue: invoice.AmountDue,
+      },
+    };
+  },
+});

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

@@ -0,0 +1,40 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getContact } from "../../lib/xero-client.ts";
+
+export default tool({
+  id: "get-contact",
+  description: "Get details of a specific Xero contact by its ID.",
+  inputSchema: z.object({
+    contactId: z.string().describe("The ID of the contact to retrieve"),
+  }),
+  async execute({ contactId }) {
+    const contact = await getContact(contactId);
+
+    return {
+      contactId: contact.ContactID,
+      contactNumber: contact.ContactNumber,
+      name: contact.Name,
+      firstName: contact.FirstName,
+      lastName: contact.LastName,
+      emailAddress: contact.EmailAddress,
+      isCustomer: contact.IsCustomer,
+      isSupplier: contact.IsSupplier,
+      addresses: contact.Addresses?.map((addr) => ({
+        addressType: addr.AddressType,
+        city: addr.City,
+        region: addr.Region,
+        postalCode: addr.PostalCode,
+        country: addr.Country,
+        attentionTo: addr.AttentionTo,
+      })),
+      phones: contact.Phones?.map((phone) => ({
+        phoneType: phone.PhoneType,
+        phoneNumber: phone.PhoneNumber,
+        phoneAreaCode: phone.PhoneAreaCode,
+        phoneCountryCode: phone.PhoneCountryCode,
+      })),
+      updatedDateUTC: contact.UpdatedDateUTC,
+    };
+  },
+});

package/dist/integrations/xero/files/ai/tools/get-invoice.ts

@@ -0,0 +1,44 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getInvoice } from "../../lib/xero-client.ts";
+
+export default tool({
+  id: "get-invoice",
+  description: "Get details of a specific Xero invoice by its ID.",
+  inputSchema: z.object({
+    invoiceId: z.string().describe("The ID of the invoice to retrieve"),
+  }),
+  async execute({ invoiceId }) {
+    const invoice = await getInvoice(invoiceId);
+
+    return {
+      invoiceId: invoice.InvoiceID,
+      invoiceNumber: invoice.InvoiceNumber,
+      type: invoice.Type,
+      status: invoice.Status,
+      contact: {
+        contactId: invoice.Contact.ContactID,
+        name: invoice.Contact.Name,
+      },
+      lineItems: invoice.LineItems.map((item) => ({
+        lineItemId: item.LineItemID,
+        description: item.Description,
+        quantity: item.Quantity,
+        unitAmount: item.UnitAmount,
+        lineAmount: item.LineAmount,
+        accountCode: item.AccountCode,
+        taxType: item.TaxType,
+      })),
+      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,
+      updatedDateUTC: invoice.UpdatedDateUTC,
+    };
+  },
+});

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

@@ -0,0 +1,54 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listContacts } from "../../lib/xero-client.ts";
+
+export default tool({
+  id: "list-contacts",
+  description:
+    "List contacts from Xero. Can filter by customer or supplier type.",
+  inputSchema: z.object({
+    isCustomer: z
+      .boolean()
+      .optional()
+      .describe("Filter for customers only"),
+    isSupplier: z
+      .boolean()
+      .optional()
+      .describe("Filter for suppliers only"),
+    limit: z
+      .number()
+      .min(1)
+      .max(100)
+      .default(20)
+      .describe("Maximum number of contacts to return"),
+  }),
+  async execute({ isCustomer, isSupplier, limit }) {
+    const contacts = await listContacts({
+      isCustomer,
+      isSupplier,
+      limit,
+    });
+
+    return contacts.map((contact) => ({
+      contactId: contact.ContactID,
+      contactNumber: contact.ContactNumber,
+      name: contact.Name,
+      firstName: contact.FirstName,
+      lastName: contact.LastName,
+      emailAddress: contact.EmailAddress,
+      isCustomer: contact.IsCustomer,
+      isSupplier: contact.IsSupplier,
+      addresses: contact.Addresses?.map((addr) => ({
+        addressType: addr.AddressType,
+        city: addr.City,
+        region: addr.Region,
+        postalCode: addr.PostalCode,
+        country: addr.Country,
+      })),
+      phones: contact.Phones?.map((phone) => ({
+        phoneType: phone.PhoneType,
+        phoneNumber: phone.PhoneNumber,
+      })),
+    }));
+  },
+});

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);