veryfront 0.0.49 → 0.0.50

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * Google Sheets OAuth Initiation
+ */
+
+import { createOAuthInitHandler, memoryTokenStore, sheetsConfig } from "veryfront/oauth";
+
+export const GET = createOAuthInitHandler(sheetsConfig, {
+  tokenStore: memoryTokenStore,
+});

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

@@ -0,0 +1,425 @@
+/**
+ * Google Sheets API Client
+ *
+ * Provides a type-safe interface to Google Sheets API operations.
+ */
+
+import { tokenStore as _tokenStore } from "./token-store.ts";
+import { getValidToken } from "./oauth.ts";
+
+// Helper for Cross-Platform environment access
+function getEnv(key: string): string | undefined {
+  // @ts-ignore - Deno global
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore - Deno global
+    return Deno.env.get(key);
+  } // @ts-ignore - process global
+  else if (typeof process !== "undefined" && process.env) {
+    // @ts-ignore - process global
+    return process.env[key];
+  }
+  return undefined;
+}
+
+const SHEETS_API_BASE = "https://sheets.googleapis.com/v4";
+const DRIVE_API_BASE = "https://www.googleapis.com/drive/v3";
+
+export interface Spreadsheet {
+  spreadsheetId: string;
+  properties: {
+    title: string;
+    locale: string;
+    autoRecalc: string;
+    timeZone: string;
+  };
+  sheets: Sheet[];
+  spreadsheetUrl: string;
+}
+
+export interface Sheet {
+  properties: {
+    sheetId: number;
+    title: string;
+    index: number;
+    sheetType: "GRID" | "OBJECT";
+    gridProperties?: {
+      rowCount: number;
+      columnCount: number;
+    };
+  };
+}
+
+export interface SpreadsheetFile {
+  id: string;
+  name: string;
+  mimeType: string;
+  createdTime: string;
+  modifiedTime: string;
+  webViewLink: string;
+}
+
+export interface CellData {
+  values: unknown[][];
+  range: string;
+}
+
+export interface CreateSpreadsheetOptions {
+  title: string;
+  sheets?: Array<{
+    title: string;
+    rowCount?: number;
+    columnCount?: number;
+  }>;
+}
+
+export interface WriteRangeOptions {
+  spreadsheetId: string;
+  range: string;
+  values: unknown[][];
+  valueInputOption?: "RAW" | "USER_ENTERED";
+}
+
+/**
+ * Google Sheets OAuth provider configuration
+ */
+export const sheetsOAuthProvider = {
+  name: "sheets",
+  authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+  tokenUrl: "https://oauth2.googleapis.com/token",
+  clientId: getEnv("GOOGLE_CLIENT_ID") || "",
+  clientSecret: getEnv("GOOGLE_CLIENT_SECRET") || "",
+  scopes: [
+    "https://www.googleapis.com/auth/spreadsheets",
+    "https://www.googleapis.com/auth/drive.readonly",
+  ],
+  callbackPath: "/api/auth/sheets/callback",
+};
+
+/**
+ * Create a Sheets client for a specific user
+ */
+export function createSheetsClient(userId: string) {
+  async function getAccessToken(): Promise<string> {
+    const token = await getValidToken(sheetsOAuthProvider, userId, "sheets");
+    if (!token) {
+      throw new Error("Google Sheets not connected. Please connect your Google account first.");
+    }
+    return token;
+  }
+
+  async function sheetsApiRequest<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    const accessToken = await getAccessToken();
+
+    const response = await fetch(`${SHEETS_API_BASE}${endpoint}`, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Sheets API error: ${response.status} - ${error}`);
+    }
+
+    return response.json();
+  }
+
+  async function driveApiRequest<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    const accessToken = await getAccessToken();
+
+    const response = await fetch(`${DRIVE_API_BASE}${endpoint}`, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Drive API error: ${response.status} - ${error}`);
+    }
+
+    return response.json();
+  }
+
+  return {
+    /**
+     * List spreadsheets from Google Drive
+     */
+    async listSpreadsheets(options: {
+      maxResults?: number;
+      orderBy?: "createdTime" | "modifiedTime" | "name";
+    } = {}): Promise<SpreadsheetFile[]> {
+      const params = new URLSearchParams({
+        q: "mimeType='application/vnd.google-apps.spreadsheet' and trashed=false",
+        fields: "files(id,name,mimeType,createdTime,modifiedTime,webViewLink)",
+        pageSize: String(options.maxResults || 20),
+        orderBy: `${options.orderBy || "modifiedTime"} desc`,
+      });
+
+      const result = await driveApiRequest<{ files: SpreadsheetFile[] }>(
+        `/files?${params.toString()}`,
+      );
+
+      return result.files || [];
+    },
+
+    /**
+     * Get spreadsheet metadata
+     */
+    getSpreadsheet(spreadsheetId: string): Promise<Spreadsheet> {
+      return sheetsApiRequest<Spreadsheet>(
+        `/spreadsheets/${spreadsheetId}`,
+      );
+    },
+
+    /**
+     * Read data from a range
+     */
+    async readRange(
+      spreadsheetId: string,
+      range: string,
+    ): Promise<CellData> {
+      const result = await sheetsApiRequest<{
+        values?: unknown[][];
+        range: string;
+      }>(
+        `/spreadsheets/${spreadsheetId}/values/${encodeURIComponent(range)}`,
+      );
+
+      return {
+        values: result.values || [],
+        range: result.range,
+      };
+    },
+
+    /**
+     * Read multiple ranges at once
+     */
+    async readRanges(
+      spreadsheetId: string,
+      ranges: string[],
+    ): Promise<CellData[]> {
+      const params = new URLSearchParams();
+      ranges.forEach((range) => params.append("ranges", range));
+
+      const result = await sheetsApiRequest<{
+        valueRanges: Array<{ values?: unknown[][]; range: string }>;
+      }>(
+        `/spreadsheets/${spreadsheetId}/values:batchGet?${params.toString()}`,
+      );
+
+      return result.valueRanges.map((vr) => ({
+        values: vr.values || [],
+        range: vr.range,
+      }));
+    },
+
+    /**
+     * Write data to a range
+     */
+    async writeRange(options: WriteRangeOptions): Promise<{
+      updatedRange: string;
+      updatedRows: number;
+      updatedColumns: number;
+      updatedCells: number;
+    }> {
+      const result = await sheetsApiRequest<{
+        updatedRange: string;
+        updatedRows: number;
+        updatedColumns: number;
+        updatedCells: number;
+      }>(
+        `/spreadsheets/${options.spreadsheetId}/values/${
+          encodeURIComponent(options.range)
+        }?valueInputOption=${options.valueInputOption || "USER_ENTERED"}`,
+        {
+          method: "PUT",
+          body: JSON.stringify({
+            values: options.values,
+          }),
+        },
+      );
+
+      return result;
+    },
+
+    /**
+     * Append data to a range
+     */
+    async appendRange(
+      spreadsheetId: string,
+      range: string,
+      values: unknown[][],
+      valueInputOption: "RAW" | "USER_ENTERED" = "USER_ENTERED",
+    ): Promise<{
+      updates: {
+        updatedRange: string;
+        updatedRows: number;
+        updatedColumns: number;
+        updatedCells: number;
+      };
+    }> {
+      const result = await sheetsApiRequest<{
+        updates: {
+          updatedRange: string;
+          updatedRows: number;
+          updatedColumns: number;
+          updatedCells: number;
+        };
+      }>(
+        `/spreadsheets/${spreadsheetId}/values/${
+          encodeURIComponent(range)
+        }:append?valueInputOption=${valueInputOption}`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            values,
+          }),
+        },
+      );
+
+      return result;
+    },
+
+    /**
+     * Clear a range
+     */
+    async clearRange(
+      spreadsheetId: string,
+      range: string,
+    ): Promise<{ clearedRange: string }> {
+      const result = await sheetsApiRequest<{ clearedRange: string }>(
+        `/spreadsheets/${spreadsheetId}/values/${encodeURIComponent(range)}:clear`,
+        {
+          method: "POST",
+        },
+      );
+
+      return result;
+    },
+
+    /**
+     * Create a new spreadsheet
+     */
+    createSpreadsheet(
+      options: CreateSpreadsheetOptions,
+    ): Promise<Spreadsheet> {
+      const body: {
+        properties: { title: string };
+        sheets?: Array<{
+          properties: {
+            title: string;
+            gridProperties?: {
+              rowCount: number;
+              columnCount: number;
+            };
+          };
+        }>;
+      } = {
+        properties: {
+          title: options.title,
+        },
+      };
+
+      if (options.sheets && options.sheets.length > 0) {
+        body.sheets = options.sheets.map((sheet) => ({
+          properties: {
+            title: sheet.title,
+            gridProperties: {
+              rowCount: sheet.rowCount || 1000,
+              columnCount: sheet.columnCount || 26,
+            },
+          },
+        }));
+      }
+
+      return sheetsApiRequest<Spreadsheet>("/spreadsheets", {
+        method: "POST",
+        body: JSON.stringify(body),
+      });
+    },
+
+    /**
+     * Add a new sheet to an existing spreadsheet
+     */
+    async addSheet(
+      spreadsheetId: string,
+      title: string,
+      options?: {
+        rowCount?: number;
+        columnCount?: number;
+      },
+    ): Promise<Sheet> {
+      const result = await sheetsApiRequest<{
+        replies: Array<{
+          addSheet?: { properties: Sheet["properties"] };
+        }>;
+      }>(
+        `/spreadsheets/${spreadsheetId}:batchUpdate`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            requests: [
+              {
+                addSheet: {
+                  properties: {
+                    title,
+                    gridProperties: {
+                      rowCount: options?.rowCount || 1000,
+                      columnCount: options?.columnCount || 26,
+                    },
+                  },
+                },
+              },
+            ],
+          }),
+        },
+      );
+
+      const addedSheet = result.replies[0]?.addSheet;
+      if (!addedSheet) {
+        throw new Error("Failed to add sheet");
+      }
+
+      return { properties: addedSheet.properties };
+    },
+
+    /**
+     * Delete a sheet from a spreadsheet
+     */
+    async deleteSheet(
+      spreadsheetId: string,
+      sheetId: number,
+    ): Promise<void> {
+      await sheetsApiRequest(
+        `/spreadsheets/${spreadsheetId}:batchUpdate`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            requests: [
+              {
+                deleteSheet: {
+                  sheetId,
+                },
+              },
+            ],
+          }),
+        },
+      );
+    },
+  };
+}
+
+export type SheetsClient = ReturnType<typeof createSheetsClient>;

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

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

package/dist/integrations/shopify/connector.json

@@ -0,0 +1,99 @@
+{
+  "name": "shopify",
+  "displayName": "Shopify",
+  "icon": "shopify.svg",
+  "description": "Manage products, orders, and customers in your Shopify store",
+  "auth": {
+    "type": "oauth2",
+    "provider": "shopify",
+    "authorizationUrl": "https://shop.myshopify.com/admin/oauth/authorize",
+    "tokenUrl": "https://shop.myshopify.com/admin/oauth/access_token",
+    "scopes": ["read_products", "write_products", "read_orders"],
+    "callbackPath": "/api/auth/shopify/callback",
+    "requiredApis": [
+      {
+        "name": "Shopify Admin API",
+        "enableUrl": "https://partners.shopify.com"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "SHOPIFY_CLIENT_ID",
+      "description": "Shopify OAuth Client ID (API Key)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://shopify.dev/docs/apps/auth/oauth"
+    },
+    {
+      "name": "SHOPIFY_CLIENT_SECRET",
+      "description": "Shopify OAuth Client Secret (API Secret Key)",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://shopify.dev/docs/apps/auth/oauth"
+    },
+    {
+      "name": "SHOPIFY_SHOP_DOMAIN",
+      "description": "Your Shopify store domain (e.g., mystore.myshopify.com)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://shopify.dev/docs/apps/auth/oauth"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-products",
+      "name": "List Products",
+      "description": "List products in your Shopify store",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-product",
+      "name": "Get Product",
+      "description": "Get details of a specific product",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-orders",
+      "name": "List Orders",
+      "description": "List orders from your Shopify store",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-order",
+      "name": "Get Order",
+      "description": "Get details of a specific order",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-customers",
+      "name": "List Customers",
+      "description": "List customers in your Shopify store",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "list-products",
+      "title": "Show my products",
+      "prompt": "List all products in my Shopify store with their prices and inventory levels.",
+      "category": "ecommerce",
+      "icon": "shopping-bag"
+    },
+    {
+      "id": "recent-orders",
+      "title": "Show recent orders",
+      "prompt": "Show me the most recent orders from my Shopify store with customer details and order totals.",
+      "category": "ecommerce",
+      "icon": "receipt"
+    },
+    {
+      "id": "customer-list",
+      "title": "Show my customers",
+      "prompt": "List all customers in my Shopify store with their contact information and order history.",
+      "category": "ecommerce",
+      "icon": "users"
+    }
+  ],
+  "suggestedWith": ["stripe", "mailchimp", "analytics"]
+}

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

@@ -0,0 +1,5 @@
+# Shopify OAuth Configuration
+# Get your credentials from https://partners.shopify.com
+SHOPIFY_CLIENT_ID=your-client-id
+SHOPIFY_CLIENT_SECRET=your-client-secret
+SHOPIFY_SHOP_DOMAIN=mystore.myshopify.com

package/dist/integrations/shopify/files/ai/tools/get-order.ts

@@ -0,0 +1,49 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getOrder } from "../../lib/shopify-client.ts";
+
+export default tool({
+  id: "get-order",
+  description: "Get details of a specific Shopify order by its ID.",
+  inputSchema: z.object({
+    orderId: z.union([z.number(), z.string()]).describe("The ID of the order to retrieve"),
+  }),
+  async execute({ orderId }) {
+    const order = await getOrder(orderId);
+
+    return {
+      id: order.id,
+      orderNumber: order.order_number,
+      email: order.email,
+      createdAt: order.created_at,
+      updatedAt: order.updated_at,
+      totalPrice: order.total_price,
+      subtotalPrice: order.subtotal_price,
+      totalTax: order.total_tax,
+      currency: order.currency,
+      financialStatus: order.financial_status,
+      fulfillmentStatus: order.fulfillment_status,
+      customer: order.customer ? {
+        id: order.customer.id,
+        email: order.customer.email,
+        firstName: order.customer.first_name,
+        lastName: order.customer.last_name,
+      } : null,
+      lineItems: order.line_items.map((item) => ({
+        id: item.id,
+        title: item.title,
+        quantity: item.quantity,
+        price: item.price,
+        sku: item.sku,
+        variantTitle: item.variant_title,
+      })),
+      shippingAddress: order.shipping_address ? {
+        address1: order.shipping_address.address1,
+        city: order.shipping_address.city,
+        province: order.shipping_address.province,
+        country: order.shipping_address.country,
+        zip: order.shipping_address.zip,
+      } : null,
+    };
+  },
+});

package/dist/integrations/shopify/files/ai/tools/get-product.ts

@@ -0,0 +1,39 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getProduct } from "../../lib/shopify-client.ts";
+
+export default tool({
+  id: "get-product",
+  description: "Get details of a specific Shopify product by its ID.",
+  inputSchema: z.object({
+    productId: z.union([z.number(), z.string()]).describe("The ID of the product to retrieve"),
+  }),
+  async execute({ productId }) {
+    const product = await getProduct(productId);
+
+    return {
+      id: product.id,
+      title: product.title,
+      bodyHtml: product.body_html,
+      vendor: product.vendor,
+      productType: product.product_type,
+      status: product.status,
+      tags: product.tags,
+      createdAt: product.created_at,
+      updatedAt: product.updated_at,
+      publishedAt: product.published_at,
+      variants: product.variants.map((v) => ({
+        id: v.id,
+        title: v.title,
+        price: v.price,
+        sku: v.sku,
+        inventoryQuantity: v.inventory_quantity,
+      })),
+      images: product.images.map((img) => ({
+        id: img.id,
+        src: img.src,
+        alt: img.alt,
+      })),
+    };
+  },
+});

package/dist/integrations/shopify/files/ai/tools/list-customers.ts

@@ -0,0 +1,40 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listCustomers } from "../../lib/shopify-client.ts";
+
+export default tool({
+  id: "list-customers",
+  description:
+    "List customers from your Shopify store. Can search by query string.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(250).default(20).describe("Maximum number of customers to return"),
+    query: z.string().optional().describe("Search query to filter customers (e.g., email, name)"),
+  }),
+  async execute({ limit, query }) {
+    const customers = await listCustomers({ limit, query });
+
+    return customers.map((customer) => ({
+      id: customer.id,
+      email: customer.email,
+      firstName: customer.first_name,
+      lastName: customer.last_name,
+      phone: customer.phone,
+      createdAt: customer.created_at,
+      updatedAt: customer.updated_at,
+      ordersCount: customer.orders_count,
+      totalSpent: customer.total_spent,
+      tags: customer.tags,
+      state: customer.state,
+      verifiedEmail: customer.verified_email,
+      addresses: customer.addresses.map((addr) => ({
+        id: addr.id,
+        address1: addr.address1,
+        city: addr.city,
+        province: addr.province,
+        country: addr.country,
+        zip: addr.zip,
+        default: addr.default,
+      })),
+    }));
+  },
+});