veryfront 0.0.49 → 0.0.51

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

@@ -0,0 +1,52 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listOrders } from "../../lib/shopify-client.ts";
+
+export default tool({
+  id: "list-orders",
+  description:
+    "List orders from your Shopify store. Can filter by status, financial status, and fulfillment status.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(250).default(20).describe("Maximum number of orders to return"),
+    status: z.enum(["open", "closed", "cancelled", "any"]).optional().describe("Filter by order status"),
+    financialStatus: z.enum(["pending", "authorized", "paid", "refunded", "voided"]).optional().describe("Filter by financial status"),
+    fulfillmentStatus: z.enum(["shipped", "partial", "unshipped", "any", "unfulfilled"]).optional().describe("Filter by fulfillment status"),
+  }),
+  async execute({ limit, status, financialStatus, fulfillmentStatus }) {
+    const orders = await listOrders({ limit, status, financialStatus, fulfillmentStatus });
+
+    return orders.map((order) => ({
+      id: order.id,
+      orderNumber: order.order_number,
+      email: order.email,
+      createdAt: order.created_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/list-products.ts

@@ -0,0 +1,39 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listProducts } from "../../lib/shopify-client.ts";
+
+export default tool({
+  id: "list-products",
+  description:
+    "List products from your Shopify store. Can filter by status and product type.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(250).default(20).describe("Maximum number of products to return"),
+    status: z.enum(["active", "archived", "draft"]).optional().describe("Filter by product status"),
+    productType: z.string().optional().describe("Filter by product type"),
+  }),
+  async execute({ limit, status, productType }) {
+    const products = await listProducts({ limit, status, productType });
+
+    return products.map((product) => ({
+      id: product.id,
+      title: product.title,
+      vendor: product.vendor,
+      productType: product.product_type,
+      status: product.status,
+      tags: product.tags,
+      createdAt: product.created_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/app/api/auth/shopify/callback/route.ts

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

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

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

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

@@ -0,0 +1,198 @@
+import { getAccessToken } from "./token-store.ts";
+
+const SHOPIFY_SHOP_DOMAIN = process.env.SHOPIFY_SHOP_DOMAIN || "shop.myshopify.com";
+const SHOPIFY_API_VERSION = "2024-01";
+const SHOPIFY_BASE_URL = `https://${SHOPIFY_SHOP_DOMAIN}/admin/api/${SHOPIFY_API_VERSION}`;
+
+interface ShopifyProduct {
+  id: number;
+  title: string;
+  body_html: string;
+  vendor: string;
+  product_type: string;
+  created_at: string;
+  updated_at: string;
+  published_at: string | null;
+  status: string;
+  tags: string;
+  variants: Array<{
+    id: number;
+    title: string;
+    price: string;
+    sku: string;
+    inventory_quantity: number;
+  }>;
+  images: Array<{
+    id: number;
+    src: string;
+    alt: string | null;
+  }>;
+}
+
+interface ShopifyOrder {
+  id: number;
+  order_number: number;
+  email: string;
+  created_at: string;
+  updated_at: string;
+  total_price: string;
+  subtotal_price: string;
+  total_tax: string;
+  currency: string;
+  financial_status: string;
+  fulfillment_status: string | null;
+  customer: {
+    id: number;
+    email: string;
+    first_name: string;
+    last_name: string;
+  } | null;
+  line_items: Array<{
+    id: number;
+    title: string;
+    quantity: number;
+    price: string;
+    sku: string;
+    variant_title: string;
+  }>;
+  shipping_address: {
+    address1: string;
+    city: string;
+    province: string;
+    country: string;
+    zip: string;
+  } | null;
+}
+
+interface ShopifyCustomer {
+  id: number;
+  email: string;
+  first_name: string;
+  last_name: string;
+  phone: string | null;
+  created_at: string;
+  updated_at: string;
+  orders_count: number;
+  total_spent: string;
+  tags: string;
+  state: string;
+  verified_email: boolean;
+  addresses: Array<{
+    id: number;
+    address1: string;
+    city: string;
+    province: string;
+    country: string;
+    zip: string;
+    default: boolean;
+  }>;
+}
+
+async function shopifyFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Shopify. Please connect your account.");
+  }
+
+  const response = await fetch(`${SHOPIFY_BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "X-Shopify-Access-Token": token,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Shopify API error: ${response.status} ${error.errors || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function listProducts(options?: {
+  limit?: number;
+  status?: "active" | "archived" | "draft";
+  productType?: string;
+}): Promise<ShopifyProduct[]> {
+  const params = new URLSearchParams();
+  if (options?.limit) params.set("limit", options.limit.toString());
+  if (options?.status) params.set("status", options.status);
+  if (options?.productType) params.set("product_type", options.productType);
+
+  const query = params.toString() ? `?${params}` : "";
+  const response = await shopifyFetch<{ products: ShopifyProduct[] }>(`/products.json${query}`);
+  return response.products;
+}
+
+export async function getProduct(productId: number | string): Promise<ShopifyProduct> {
+  const response = await shopifyFetch<{ product: ShopifyProduct }>(`/products/${productId}.json`);
+  return response.product;
+}
+
+export async function listOrders(options?: {
+  limit?: number;
+  status?: "open" | "closed" | "cancelled" | "any";
+  financialStatus?: "pending" | "authorized" | "paid" | "refunded" | "voided";
+  fulfillmentStatus?: "shipped" | "partial" | "unshipped" | "any" | "unfulfilled";
+}): Promise<ShopifyOrder[]> {
+  const params = new URLSearchParams();
+  if (options?.limit) params.set("limit", options.limit.toString());
+  if (options?.status) params.set("status", options.status);
+  if (options?.financialStatus) params.set("financial_status", options.financialStatus);
+  if (options?.fulfillmentStatus) params.set("fulfillment_status", options.fulfillmentStatus);
+
+  const query = params.toString() ? `?${params}` : "";
+  const response = await shopifyFetch<{ orders: ShopifyOrder[] }>(`/orders.json${query}`);
+  return response.orders;
+}
+
+export async function getOrder(orderId: number | string): Promise<ShopifyOrder> {
+  const response = await shopifyFetch<{ order: ShopifyOrder }>(`/orders/${orderId}.json`);
+  return response.order;
+}
+
+export async function listCustomers(options?: {
+  limit?: number;
+  query?: string;
+}): Promise<ShopifyCustomer[]> {
+  const params = new URLSearchParams();
+  if (options?.limit) params.set("limit", options.limit.toString());
+  if (options?.query) params.set("query", options.query);
+
+  const query = params.toString() ? `?${params}` : "";
+  const response = await shopifyFetch<{ customers: ShopifyCustomer[] }>(`/customers.json${query}`);
+  return response.customers;
+}
+
+export async function getCustomer(customerId: number | string): Promise<ShopifyCustomer> {
+  const response = await shopifyFetch<{ customer: ShopifyCustomer }>(`/customers/${customerId}.json`);
+  return response.customer;
+}
+
+export async function getShopInfo(): Promise<{
+  id: number;
+  name: string;
+  email: string;
+  domain: string;
+  currency: string;
+  timezone: string;
+}> {
+  const response = await shopifyFetch<{
+    shop: {
+      id: number;
+      name: string;
+      email: string;
+      domain: string;
+      currency: string;
+      timezone: string;
+    };
+  }>("/shop.json");
+  return response.shop;
+}

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

@@ -1,132 +1,11 @@
 /**
  * Slack OAuth Callback
- *
- * Handles the OAuth callback from Slack, exchanges code for tokens,
- * and stores them securely.
  */
 
-import { tokenStore } from "../../../../../lib/token-store.ts";
-import { slackOAuthProvider } from "../../../../../lib/slack-client.ts";
+import { createOAuthCallbackHandler, memoryTokenStore, slackConfig } from "veryfront/oauth";
 
-export async function GET(req: Request) {
-  const url = new URL(req.url);
-  const code = url.searchParams.get("code");
-  const state = url.searchParams.get("state");
-  const error = url.searchParams.get("error");
-
-  // Handle OAuth errors
-  if (error) {
-    const errorDescription = url.searchParams.get("error_description") || error;
-    return new Response(
-      `
-      <html>
-        <head><title>Connection Failed</title></head>
-        <body style="font-family: system-ui; padding: 40px; text-align: center;">
-          <h1>Slack Connection Failed</h1>
-          <p style="color: #666;">${errorDescription}</p>
-          <a href="/" style="color: #0066cc;">Return to App</a>
-        </body>
-      </html>
-      `,
-      {
-        status: 400,
-        headers: { "Content-Type": "text/html" },
-      },
-    );
-  }
-
-  if (!code || !state) {
-    return new Response("Missing code or state parameter", { status: 400 });
-  }
-
-  // Validate state from cookie
-  const cookies = req.headers.get("cookie") || "";
-  const stateCookie = cookies
-    .split(";")
-    .find((c) => c.trim().startsWith("slack_oauth_state="));
-  const savedState = stateCookie?.split("=")[1]?.trim();
-
-  if (state !== savedState) {
-    return new Response("Invalid state parameter", { status: 400 });
-  }
-
-  try {
-    const origin = url.origin;
-    const redirectUri = `${origin}${slackOAuthProvider.callbackPath}`;
-
-    // Exchange code for tokens using Slack's specific OAuth flow
-    const response = await fetch(slackOAuthProvider.tokenUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-      },
-      body: new URLSearchParams({
-        client_id: slackOAuthProvider.clientId,
-        client_secret: slackOAuthProvider.clientSecret,
-        code,
-        redirect_uri: redirectUri,
-      }),
-    });
-
-    const data = await response.json();
-
-    if (!data.ok) {
-      throw new Error(data.error || "Token exchange failed");
-    }
-
-    // Get actual user ID from session in production
-    const userId = "current-user";
-
-    // Store tokens (Slack returns access_token in authed_user or at top level)
-    const accessToken = data.authed_user?.access_token || data.access_token;
-    await tokenStore.setToken(userId, "slack", {
-      accessToken,
-      refreshToken: data.refresh_token,
-      scope: data.scope,
-      tokenType: data.token_type,
-    });
-
-    // Clear state cookie and redirect to success page
-    return new Response(
-      `
-      <html>
-        <head>
-          <title>Slack Connected</title>
-          <meta http-equiv="refresh" content="2;url=/" />
-        </head>
-        <body style="font-family: system-ui; padding: 40px; text-align: center;">
-          <h1 style="color: #22c55e;">✓ Slack Connected!</h1>
-          <p style="color: #666;">Your Slack workspace has been connected successfully.</p>
-          <p style="color: #999; font-size: 14px;">Redirecting...</p>
-          <a href="/" style="color: #0066cc;">Return to App</a>
-        </body>
-      </html>
-      `,
-      {
-        status: 200,
-        headers: {
-          "Content-Type": "text/html",
-          "Set-Cookie": "slack_oauth_state=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
-        },
-      },
-    );
-  } catch (err) {
-    console.error("Slack OAuth error:", err);
-    return new Response(
-      `
-      <html>
-        <head><title>Connection Failed</title></head>
-        <body style="font-family: system-ui; padding: 40px; text-align: center;">
-          <h1>Slack Connection Failed</h1>
-          <p style="color: #666;">Unable to complete Slack authorization. Please try again.</p>
-          <a href="/api/auth/slack" style="color: #0066cc;">Try Again</a>
-        </body>
-      </html>
-      `,
-      {
-        status: 500,
-        headers: { "Content-Type": "text/html" },
-      },
-    );
-  }
-}
+export const GET = createOAuthCallbackHandler(slackConfig, {
+  tokenStore: memoryTokenStore,
+  onSuccess: () => "/",
+  onError: () => "/",
+});

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

@@ -1,29 +1,9 @@
 /**
  * Slack OAuth Initiation
- *
- * Redirects to Slack OAuth consent screen
  */
 
-import { getAuthorizationUrl } from "../../../../lib/oauth.ts";
-import { slackOAuthProvider } from "../../../../lib/slack-client.ts";
+import { createOAuthInitHandler, memoryTokenStore, slackConfig } from "veryfront/oauth";
 
-export function GET(req: Request) {
-  const url = new URL(req.url);
-  const origin = url.origin;
-
-  // Generate a random state for CSRF protection
-  const state = crypto.randomUUID();
-
-  // Store state in a cookie for validation
-  const redirectUri = `${origin}${slackOAuthProvider.callbackPath}`;
-  const authUrl = getAuthorizationUrl(slackOAuthProvider, state, redirectUri);
-
-  // Set state cookie and redirect to Slack
-  return new Response(null, {
-    status: 302,
-    headers: {
-      Location: authUrl,
-      "Set-Cookie": `slack_oauth_state=${state}; Path=/; HttpOnly; SameSite=Lax; Max-Age=600`,
-    },
-  });
-}
+export const GET = createOAuthInitHandler(slackConfig, {
+  tokenStore: memoryTokenStore,
+});

package/dist/integrations/snowflake/connector.json

@@ -0,0 +1,151 @@
+{
+  "name": "snowflake",
+  "displayName": "Snowflake",
+  "icon": "snowflake.svg",
+  "description": "Query and manage your Snowflake data warehouse with SQL operations across databases, schemas, and tables",
+  "auth": {
+    "type": "api-key",
+    "requiredApis": [
+      {
+        "name": "Snowflake Account",
+        "enableUrl": "https://app.snowflake.com/"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "SNOWFLAKE_ACCOUNT",
+      "description": "Your Snowflake account identifier (e.g., xy12345.us-east-1)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/admin-account-identifier"
+    },
+    {
+      "name": "SNOWFLAKE_USERNAME",
+      "description": "Snowflake username for authentication",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/admin-user-management"
+    },
+    {
+      "name": "SNOWFLAKE_PASSWORD",
+      "description": "Snowflake password for authentication",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/admin-user-management"
+    },
+    {
+      "name": "SNOWFLAKE_WAREHOUSE",
+      "description": "Default warehouse to use for queries (e.g., COMPUTE_WH)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/warehouses"
+    },
+    {
+      "name": "SNOWFLAKE_DATABASE",
+      "description": "Default database to use for queries",
+      "required": false,
+      "sensitive": false,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/databases"
+    },
+    {
+      "name": "SNOWFLAKE_SCHEMA",
+      "description": "Default schema to use for queries (defaults to PUBLIC)",
+      "required": false,
+      "sensitive": false,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/schemas"
+    }
+  ],
+  "tools": [
+    {
+      "id": "run-query",
+      "name": "Run Query",
+      "description": "Execute a SQL query against your Snowflake data warehouse",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-databases",
+      "name": "List Databases",
+      "description": "List all databases in your Snowflake account",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-schemas",
+      "name": "List Schemas",
+      "description": "List all schemas in a Snowflake database",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-tables",
+      "name": "List Tables",
+      "description": "List all tables in a Snowflake database schema",
+      "requiresWrite": false
+    },
+    {
+      "id": "describe-table",
+      "name": "Describe Table",
+      "description": "Get detailed column information for a specific table",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "query-data",
+      "title": "Query my data warehouse",
+      "prompt": "Help me query data from my Snowflake data warehouse. Show me specific records or analyze patterns.",
+      "category": "data",
+      "icon": "search"
+    },
+    {
+      "id": "analyze-tables",
+      "title": "Analyze table structure",
+      "prompt": "Show me the structure of tables in my Snowflake database and help me understand the schema.",
+      "category": "data",
+      "icon": "database"
+    },
+    {
+      "id": "data-insights",
+      "title": "Generate insights",
+      "prompt": "Analyze my Snowflake data and generate insights about trends, patterns, and anomalies.",
+      "category": "analytics",
+      "icon": "chart"
+    },
+    {
+      "id": "optimize-queries",
+      "title": "Optimize queries",
+      "prompt": "Help me optimize my SQL queries for better performance in Snowflake.",
+      "category": "analytics",
+      "icon": "lightning"
+    }
+  ],
+  "setupGuide": {
+    "steps": [
+      {
+        "title": "Locate Your Account Identifier",
+        "description": "Find your Snowflake account identifier in the Snowflake web interface URL (e.g., xy12345.us-east-1 from https://xy12345.us-east-1.snowflakecomputing.com)",
+        "docsUrl": "https://docs.snowflake.com/en/user-guide/admin-account-identifier"
+      },
+      {
+        "title": "Create or Use Existing User",
+        "description": "Use an existing Snowflake user or create a new one with appropriate permissions. The user needs USAGE privileges on the warehouse and database, and SELECT privileges on tables.",
+        "docsUrl": "https://docs.snowflake.com/en/user-guide/admin-user-management"
+      },
+      {
+        "title": "Configure Warehouse",
+        "description": "Ensure you have a warehouse created and running. The default warehouse is typically named COMPUTE_WH.",
+        "docsUrl": "https://docs.snowflake.com/en/user-guide/warehouses"
+      },
+      {
+        "title": "Set Environment Variables",
+        "description": "Add the following environment variables to your .env file with your Snowflake credentials",
+        "code": "SNOWFLAKE_ACCOUNT=xy12345.us-east-1\nSNOWFLAKE_USERNAME=your_username\nSNOWFLAKE_PASSWORD=your_password\nSNOWFLAKE_WAREHOUSE=COMPUTE_WH\nSNOWFLAKE_DATABASE=your_database\nSNOWFLAKE_SCHEMA=PUBLIC"
+      },
+      {
+        "title": "Test Connection",
+        "description": "Test your connection by listing databases or running a simple query",
+        "code": "SELECT CURRENT_VERSION()"
+      }
+    ]
+  },
+  "suggestedWith": ["github", "slack", "notion"]
+}

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

@@ -0,0 +1,16 @@
+# Snowflake Integration
+# Get your account details from https://app.snowflake.com/
+
+# Your Snowflake account identifier (e.g., xy12345.us-east-1)
+SNOWFLAKE_ACCOUNT=xy12345.us-east-1
+
+# Authentication credentials
+SNOWFLAKE_USERNAME=your_username
+SNOWFLAKE_PASSWORD=your_password
+
+# Default warehouse for compute resources
+SNOWFLAKE_WAREHOUSE=COMPUTE_WH
+
+# Optional: Default database and schema
+SNOWFLAKE_DATABASE=your_database
+SNOWFLAKE_SCHEMA=PUBLIC