veryfront 0.0.49 → 0.0.51

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

@@ -0,0 +1,376 @@
+import { getApiKey } from "./token-store.ts";
+
+const STRIPE_API_VERSION = "2024-12-18.acacia";
+const STRIPE_BASE_URL = "https://api.stripe.com/v1";
+
+// Types
+export interface StripeCustomer {
+  id: string;
+  object: "customer";
+  email: string | null;
+  name: string | null;
+  description: string | null;
+  created: number;
+  metadata: Record<string, string>;
+  balance: number;
+  currency: string | null;
+  default_source: string | null;
+}
+
+export interface StripePaymentIntent {
+  id: string;
+  object: "payment_intent";
+  amount: number;
+  currency: string;
+  status:
+    | "requires_payment_method"
+    | "requires_confirmation"
+    | "requires_action"
+    | "processing"
+    | "requires_capture"
+    | "canceled"
+    | "succeeded";
+  customer: string | null;
+  description: string | null;
+  created: number;
+  metadata: Record<string, string>;
+  receipt_email: string | null;
+}
+
+export interface StripeSubscription {
+  id: string;
+  object: "subscription";
+  customer: string;
+  status:
+    | "incomplete"
+    | "incomplete_expired"
+    | "trialing"
+    | "active"
+    | "past_due"
+    | "canceled"
+    | "unpaid"
+    | "paused";
+  current_period_start: number;
+  current_period_end: number;
+  created: number;
+  canceled_at: number | null;
+  metadata: Record<string, string>;
+  items: {
+    data: Array<{
+      id: string;
+      price: {
+        id: string;
+        unit_amount: number;
+        currency: string;
+        recurring: { interval: string; interval_count: number };
+      };
+    }>;
+  };
+}
+
+export interface StripeBalance {
+  object: "balance";
+  available: Array<{ amount: number; currency: string; source_types?: Record<string, number> }>;
+  pending: Array<{ amount: number; currency: string; source_types?: Record<string, number> }>;
+  livemode: boolean;
+}
+
+export interface StripeBalanceTransaction {
+  id: string;
+  object: "balance_transaction";
+  amount: number;
+  currency: string;
+  description: string | null;
+  fee: number;
+  net: number;
+  status: "available" | "pending";
+  type: string;
+  created: number;
+}
+
+interface StripeListResponse<T> {
+  object: "list";
+  data: T[];
+  has_more: boolean;
+  url: string;
+}
+
+interface StripeError {
+  error: {
+    message: string;
+    type: string;
+    code?: string;
+    param?: string;
+  };
+}
+
+// Helper function for Stripe API calls
+async function stripeFetch<T>(
+  endpoint: string,
+  options: RequestInit & { params?: Record<string, string | number | boolean> } = {},
+): Promise<T> {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("Not authenticated with Stripe. Please set STRIPE_SECRET_KEY.");
+  }
+
+  // Build URL with query parameters
+  let url = `${STRIPE_BASE_URL}${endpoint}`;
+  if (options.params) {
+    const params = new URLSearchParams();
+    Object.entries(options.params).forEach(([key, value]) => {
+      params.append(key, String(value));
+    });
+    url += `?${params.toString()}`;
+  }
+
+  // For POST requests with body data, use form-urlencoded
+  const headers: Record<string, string> = {
+    "Authorization": `Bearer ${apiKey}`,
+    "Stripe-Version": STRIPE_API_VERSION,
+    ...options.headers as Record<string, string>,
+  };
+
+  // Convert JSON body to form-urlencoded for Stripe API
+  let body = options.body;
+  if (options.method === "POST" && options.body && typeof options.body === "string") {
+    try {
+      const jsonBody = JSON.parse(options.body);
+      const formData = new URLSearchParams();
+
+      // Flatten nested objects for form encoding
+      const flattenObject = (obj: Record<string, unknown>, prefix = "") => {
+        for (const [key, value] of Object.entries(obj)) {
+          const formKey = prefix ? `${prefix}[${key}]` : key;
+          if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+            flattenObject(value as Record<string, unknown>, formKey);
+          } else if (value !== undefined && value !== null) {
+            formData.append(formKey, String(value));
+          }
+        }
+      };
+
+      flattenObject(jsonBody);
+      body = formData.toString();
+      headers["Content-Type"] = "application/x-www-form-urlencoded";
+    } catch {
+      // If not JSON, use as-is
+    }
+  }
+
+  const response = await fetch(url, {
+    ...options,
+    headers,
+    body,
+  });
+
+  const data = await response.json();
+
+  if (!response.ok) {
+    const error = data as StripeError;
+    throw new Error(
+      `Stripe API error: ${response.status} ${error.error?.message || response.statusText}`,
+    );
+  }
+
+  return data as T;
+}
+
+// Customer operations
+export async function listCustomers(options?: {
+  limit?: number;
+  email?: string;
+  created?: { gt?: number; gte?: number; lt?: number; lte?: number };
+}): Promise<StripeCustomer[]> {
+  const params: Record<string, string | number> = {
+    limit: options?.limit || 10,
+  };
+
+  if (options?.email) {
+    params.email = options.email;
+  }
+
+  if (options?.created) {
+    if (options.created.gt) params["created[gt]"] = options.created.gt;
+    if (options.created.gte) params["created[gte]"] = options.created.gte;
+    if (options.created.lt) params["created[lt]"] = options.created.lt;
+    if (options.created.lte) params["created[lte]"] = options.created.lte;
+  }
+
+  const response = await stripeFetch<StripeListResponse<StripeCustomer>>(
+    "/customers",
+    { params },
+  );
+
+  return response.data;
+}
+
+export function getCustomer(customerId: string): Promise<StripeCustomer> {
+  return stripeFetch<StripeCustomer>(`/customers/${customerId}`);
+}
+
+export function createCustomer(data: {
+  email?: string;
+  name?: string;
+  description?: string;
+  metadata?: Record<string, string>;
+}): Promise<StripeCustomer> {
+  return stripeFetch<StripeCustomer>("/customers", {
+    method: "POST",
+    body: JSON.stringify(data),
+  });
+}
+
+export function updateCustomer(
+  customerId: string,
+  data: {
+    email?: string;
+    name?: string;
+    description?: string;
+    metadata?: Record<string, string>;
+  },
+): Promise<StripeCustomer> {
+  return stripeFetch<StripeCustomer>(`/customers/${customerId}`, {
+    method: "POST",
+    body: JSON.stringify(data),
+  });
+}
+
+// Payment Intent operations
+export async function listPaymentIntents(options?: {
+  limit?: number;
+  customer?: string;
+  created?: { gt?: number; gte?: number; lt?: number; lte?: number };
+}): Promise<StripePaymentIntent[]> {
+  const params: Record<string, string | number> = {
+    limit: options?.limit || 10,
+  };
+
+  if (options?.customer) {
+    params.customer = options.customer;
+  }
+
+  if (options?.created) {
+    if (options.created.gt) params["created[gt]"] = options.created.gt;
+    if (options.created.gte) params["created[gte]"] = options.created.gte;
+    if (options.created.lt) params["created[lt]"] = options.created.lt;
+    if (options.created.lte) params["created[lte]"] = options.created.lte;
+  }
+
+  const response = await stripeFetch<StripeListResponse<StripePaymentIntent>>(
+    "/payment_intents",
+    { params },
+  );
+
+  return response.data;
+}
+
+export function getPaymentIntent(paymentIntentId: string): Promise<StripePaymentIntent> {
+  return stripeFetch<StripePaymentIntent>(`/payment_intents/${paymentIntentId}`);
+}
+
+export function createPaymentIntent(data: {
+  amount: number;
+  currency: string;
+  customer?: string;
+  description?: string;
+  metadata?: Record<string, string>;
+  payment_method?: string;
+  confirm?: boolean;
+}): Promise<StripePaymentIntent> {
+  return stripeFetch<StripePaymentIntent>("/payment_intents", {
+    method: "POST",
+    body: JSON.stringify(data),
+  });
+}
+
+// Subscription operations
+export async function listSubscriptions(options?: {
+  limit?: number;
+  customer?: string;
+  status?:
+    | "incomplete"
+    | "incomplete_expired"
+    | "trialing"
+    | "active"
+    | "past_due"
+    | "canceled"
+    | "unpaid"
+    | "paused";
+  created?: { gt?: number; gte?: number; lt?: number; lte?: number };
+}): Promise<StripeSubscription[]> {
+  const params: Record<string, string | number> = {
+    limit: options?.limit || 10,
+  };
+
+  if (options?.customer) {
+    params.customer = options.customer;
+  }
+
+  if (options?.status) {
+    params.status = options.status;
+  }
+
+  if (options?.created) {
+    if (options.created.gt) params["created[gt]"] = options.created.gt;
+    if (options.created.gte) params["created[gte]"] = options.created.gte;
+    if (options.created.lt) params["created[lt]"] = options.created.lt;
+    if (options.created.lte) params["created[lte]"] = options.created.lte;
+  }
+
+  const response = await stripeFetch<StripeListResponse<StripeSubscription>>(
+    "/subscriptions",
+    { params },
+  );
+
+  return response.data;
+}
+
+export function getSubscription(subscriptionId: string): Promise<StripeSubscription> {
+  return stripeFetch<StripeSubscription>(`/subscriptions/${subscriptionId}`);
+}
+
+// Balance operations
+export function getBalance(): Promise<StripeBalance> {
+  return stripeFetch<StripeBalance>("/balance");
+}
+
+export async function listBalanceTransactions(options?: {
+  limit?: number;
+  created?: { gt?: number; gte?: number; lt?: number; lte?: number };
+  type?: string;
+}): Promise<StripeBalanceTransaction[]> {
+  const params: Record<string, string | number> = {
+    limit: options?.limit || 10,
+  };
+
+  if (options?.created) {
+    if (options.created.gt) params["created[gt]"] = options.created.gt;
+    if (options.created.gte) params["created[gte]"] = options.created.gte;
+    if (options.created.lt) params["created[lt]"] = options.created.lt;
+    if (options.created.lte) params["created[lte]"] = options.created.lte;
+  }
+
+  if (options?.type) {
+    params.type = options.type;
+  }
+
+  const response = await stripeFetch<StripeListResponse<StripeBalanceTransaction>>(
+    "/balance_transactions",
+    { params },
+  );
+
+  return response.data;
+}
+
+// Helper functions
+export function formatAmount(amount: number, currency: string): string {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: currency.toUpperCase(),
+  }).format(amount / 100);
+}
+
+export function formatDate(timestamp: number): string {
+  return new Date(timestamp * 1000).toISOString();
+}

package/dist/integrations/supabase/connector.json

@@ -0,0 +1,101 @@
+{
+  "name": "supabase",
+  "displayName": "Supabase",
+  "icon": "supabase.svg",
+  "description": "Query and manage your Supabase database with full CRUD operations",
+  "auth": {
+    "type": "api-key",
+    "requiredApis": [
+      {
+        "name": "Supabase Project",
+        "enableUrl": "https://supabase.com/dashboard/projects"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "SUPABASE_URL",
+      "description": "Your Supabase project URL (e.g., https://xxxxx.supabase.co)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://supabase.com/docs/guides/api#api-url-and-keys"
+    },
+    {
+      "name": "SUPABASE_ANON_KEY",
+      "description": "Supabase anonymous/public API key for client-side operations",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://supabase.com/docs/guides/api#api-url-and-keys"
+    },
+    {
+      "name": "SUPABASE_SERVICE_KEY",
+      "description": "Supabase service role key for server-side operations (bypasses RLS)",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://supabase.com/docs/guides/api#api-url-and-keys"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-tables",
+      "name": "List Tables",
+      "description": "List all tables in your Supabase database",
+      "requiresWrite": false
+    },
+    {
+      "id": "query-table",
+      "name": "Query Table",
+      "description": "Select rows from a table with optional filters and sorting",
+      "requiresWrite": false
+    },
+    {
+      "id": "insert-row",
+      "name": "Insert Row",
+      "description": "Insert a new row into a table",
+      "requiresWrite": true
+    },
+    {
+      "id": "update-row",
+      "name": "Update Row",
+      "description": "Update an existing row in a table",
+      "requiresWrite": true
+    },
+    {
+      "id": "delete-row",
+      "name": "Delete Row",
+      "description": "Delete a row from a table",
+      "requiresWrite": true
+    }
+  ],
+  "prompts": [
+    {
+      "id": "query-data",
+      "title": "Query my database",
+      "prompt": "Help me query data from my Supabase database. Show me specific records or analyze patterns.",
+      "category": "data",
+      "icon": "search"
+    },
+    {
+      "id": "create-record",
+      "title": "Create a record",
+      "prompt": "Create a new record in my Supabase database with the information I provide.",
+      "category": "data",
+      "icon": "plus"
+    },
+    {
+      "id": "update-records",
+      "title": "Update records",
+      "prompt": "Find and update records in my Supabase database based on specific criteria.",
+      "category": "data",
+      "icon": "edit"
+    },
+    {
+      "id": "database-stats",
+      "title": "Database statistics",
+      "prompt": "Show me statistics and insights about my Supabase database tables and data.",
+      "category": "analytics",
+      "icon": "chart"
+    }
+  ],
+  "suggestedWith": ["github", "slack", "linear"]
+}

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

@@ -0,0 +1,6 @@
+# Supabase Integration
+# Get your API keys from https://supabase.com/dashboard/project/_/settings/api
+
+SUPABASE_URL=https://xxxxx.supabase.co
+SUPABASE_ANON_KEY=your_anon_key_here
+SUPABASE_SERVICE_KEY=your_service_role_key_here

package/dist/integrations/supabase/files/ai/tools/delete-row.ts

@@ -0,0 +1,77 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { deleteRow, deleteRows } from "../../lib/supabase-client.ts";
+
+export default tool({
+  id: "delete-row",
+  description:
+    "Delete rows from a Supabase table. Can delete by ID or by custom filter conditions. Returns the deleted rows.",
+  inputSchema: z.object({
+    tableName: z.string().describe("The name of the table to delete from"),
+    id: z.union([z.string(), z.number()]).optional().describe(
+      "The ID of the row to delete (if deleting a single row by ID)",
+    ),
+    filter: z.record(z.unknown()).optional().describe(
+      'Filter conditions to match rows to delete (e.g., {"status": "archived"})',
+    ),
+    confirm: z.boolean().default(false).describe(
+      "Confirm deletion (must be true to proceed with delete operation)",
+    ),
+  }),
+  async execute({ tableName, id, filter, confirm }) {
+    // Require confirmation for delete operations
+    if (!confirm) {
+      return {
+        success: false,
+        tableName,
+        error: "Deletion not confirmed",
+        message: "You must set confirm: true to delete rows. This is a safety measure.",
+      };
+    }
+
+    try {
+      // Validate that either id or filter is provided
+      if (!id && !filter) {
+        return {
+          success: false,
+          tableName,
+          error: "Either id or filter must be provided",
+          message: "You must specify either an id or filter conditions to delete rows",
+        };
+      }
+
+      // Delete by ID (single row)
+      if (id) {
+        const result = await deleteRow(tableName, id);
+        return {
+          success: true,
+          tableName,
+          rowsDeleted: 1,
+          row: result,
+          message: `Successfully deleted row with id ${id} from ${tableName}`,
+        };
+      }
+
+      // Delete by filter (multiple rows)
+      if (filter) {
+        const results = await deleteRows(tableName, filter);
+        return {
+          success: true,
+          tableName,
+          rowsDeleted: results.length,
+          rows: results,
+          message: `Successfully deleted ${results.length} row(s) from ${tableName}`,
+        };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+
+      return {
+        success: false,
+        tableName,
+        error: errorMessage,
+        message: `Failed to delete row(s) from ${tableName}: ${errorMessage}`,
+      };
+    }
+  },
+});

package/dist/integrations/supabase/files/ai/tools/insert-row.ts

@@ -0,0 +1,35 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { insertRow } from "../../lib/supabase-client.ts";
+
+export default tool({
+  id: "insert-row",
+  description: "Insert a new row into a Supabase table. Returns the created row.",
+  inputSchema: z.object({
+    tableName: z.string().describe("The name of the table to insert into"),
+    data: z.record(z.unknown()).describe(
+      "The data to insert as key-value pairs matching the table schema",
+    ),
+  }),
+  async execute({ tableName, data }) {
+    try {
+      const result = await insertRow(tableName, data);
+
+      return {
+        success: true,
+        tableName,
+        row: result,
+        message: `Successfully inserted row into ${tableName}`,
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+
+      return {
+        success: false,
+        tableName,
+        error: errorMessage,
+        message: `Failed to insert row into ${tableName}: ${errorMessage}`,
+      };
+    }
+  },
+});

package/dist/integrations/supabase/files/ai/tools/list-tables.ts

@@ -0,0 +1,60 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getTableColumns, listTables } from "../../lib/supabase-client.ts";
+
+export default tool({
+  id: "list-tables",
+  description: "List all tables in your Supabase database with their schema information.",
+  inputSchema: z.object({
+    includeColumns: z.boolean().default(false).describe(
+      "Include column information for each table",
+    ),
+  }),
+  async execute({ includeColumns }) {
+    const tables = await listTables();
+
+    if (!includeColumns) {
+      return {
+        count: tables.length,
+        tables: tables.map((t) => ({
+          name: t.table_name,
+          schema: t.table_schema,
+          type: t.table_type,
+        })),
+      };
+    }
+
+    // Fetch column information for each table
+    const tablesWithColumns = await Promise.all(
+      tables.map(async (table) => {
+        try {
+          const columns = await getTableColumns(table.table_name);
+          return {
+            name: table.table_name,
+            schema: table.table_schema,
+            type: table.table_type,
+            columns: columns.map((c) => ({
+              name: c.column_name,
+              type: c.data_type,
+              nullable: c.is_nullable === "YES",
+              default: c.column_default,
+            })),
+          };
+        } catch (error) {
+          return {
+            name: table.table_name,
+            schema: table.table_schema,
+            type: table.table_type,
+            columns: [],
+            error: error instanceof Error ? error.message : "Failed to fetch columns",
+          };
+        }
+      }),
+    );
+
+    return {
+      count: tablesWithColumns.length,
+      tables: tablesWithColumns,
+    };
+  },
+});

package/dist/integrations/supabase/files/ai/tools/query-table.ts

@@ -0,0 +1,48 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { queryTable } from "../../lib/supabase-client.ts";
+
+export default tool({
+  id: "query-table",
+  description:
+    "Query a table in your Supabase database with optional filters, sorting, and pagination.",
+  inputSchema: z.object({
+    tableName: z.string().describe("The name of the table to query"),
+    select: z.string().optional().describe(
+      'Columns to select (comma-separated, e.g., "id,name,email"). Default is all columns (*)',
+    ),
+    filter: z.record(z.unknown()).optional().describe(
+      'Filter conditions as key-value pairs (e.g., {"status": "active", "age": 25})',
+    ),
+    orderBy: z.string().optional().describe("Column to order by"),
+    ascending: z.boolean().default(true).describe(
+      "Sort in ascending order (true) or descending (false)",
+    ),
+    limit: z.number().min(1).max(1000).default(100).describe(
+      "Maximum number of rows to return (1-1000)",
+    ),
+    offset: z.number().min(0).default(0).describe("Number of rows to skip (for pagination)"),
+  }),
+  async execute({ tableName, select, filter, orderBy, ascending, limit, offset }) {
+    const options = {
+      select,
+      filter,
+      order: orderBy ? { column: orderBy, ascending } : undefined,
+      limit,
+      offset,
+    };
+
+    const results = await queryTable(tableName, options);
+
+    return {
+      tableName,
+      count: results.length,
+      rows: results,
+      pagination: {
+        limit,
+        offset,
+        hasMore: results.length === limit,
+      },
+    };
+  },
+});