veryfront 0.0.49 → 0.0.50

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

@@ -0,0 +1,389 @@
+import {
+  getSnowflakeAccount,
+  getSnowflakeDatabase,
+  getSnowflakePassword,
+  getSnowflakeSchema,
+  getSnowflakeUsername,
+  getSnowflakeWarehouse,
+} from "./token-store.ts";
+
+/**
+ * Snowflake SQL REST API Response Types
+ * Based on: https://docs.snowflake.com/en/developer-guide/sql-api/reference
+ */
+
+interface SnowflakeStatementResponse {
+  statementHandle: string;
+  statementStatusUrl: string;
+  message?: string;
+  code?: string;
+}
+
+interface SnowflakeQueryResult {
+  resultSetMetaData: {
+    rowType: Array<{
+      name: string;
+      type: string;
+      nullable: boolean;
+      scale?: number;
+      precision?: number;
+      length?: number;
+    }>;
+    numRows: number;
+    format?: string;
+    partitionInfo?: Array<{
+      rowCount: number;
+      uncompressedSize: number;
+    }>;
+  };
+  data: unknown[][];
+  code?: string;
+  message?: string;
+  statementHandle?: string;
+  statementStatusUrl?: string;
+}
+
+interface SnowflakeQueryStatusResponse {
+  message: string;
+  code: string;
+  statementHandle: string;
+  statementStatusUrl: string;
+  sqlText?: string;
+  resultSetMetaData?: SnowflakeQueryResult["resultSetMetaData"];
+  data?: unknown[][];
+  stats?: {
+    numRowsInserted?: number;
+    numRowsUpdated?: number;
+    numRowsDeleted?: number;
+    numDuplicateRowsUpdated?: number;
+  };
+}
+
+interface DatabaseInfo {
+  name: string;
+  created_on: string;
+  owner: string;
+  comment?: string;
+}
+
+interface SchemaInfo {
+  name: string;
+  database_name: string;
+  created_on: string;
+  owner: string;
+  comment?: string;
+}
+
+interface TableInfo {
+  name: string;
+  database_name: string;
+  schema_name: string;
+  kind: string;
+  created_on: string;
+  row_count?: number;
+  bytes?: number;
+  owner: string;
+  comment?: string;
+}
+
+interface ColumnInfo {
+  name: string;
+  type: string;
+  kind: string;
+  null?: string;
+  default?: string;
+  primary_key?: string;
+  unique_key?: string;
+  check?: string;
+  expression?: string;
+  comment?: string;
+}
+
+interface SnowflakeError extends Error {
+  code?: string;
+  sqlState?: string;
+}
+
+/**
+ * Execute a Snowflake SQL API request
+ */
+async function snowflakeFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const account = getSnowflakeAccount();
+  const username = getSnowflakeUsername();
+  const password = getSnowflakePassword();
+
+  // Construct the base URL for Snowflake SQL REST API
+  const baseUrl = `https://${account}.snowflakecomputing.com/api/v2`;
+
+  // Create basic auth header
+  const authHeader = `Basic ${btoa(`${username}:${password}`)}`;
+
+  const response = await fetch(`${baseUrl}${endpoint}`, {
+    ...options,
+    headers: {
+      "Authorization": authHeader,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "X-Snowflake-Authorization-Token-Type": "KEYPAIR_JWT",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({})) as SnowflakeError;
+    const errorMessage = errorData.message ||
+      `Snowflake API error: ${response.status} ${response.statusText}`;
+    const err: SnowflakeError = new Error(errorMessage);
+    err.code = errorData.code;
+    err.sqlState = errorData.sqlState;
+    throw err;
+  }
+
+  return await response.json();
+}
+
+/**
+ * Submit a SQL statement for execution
+ */
+async function submitStatement(
+  sqlText: string,
+  database?: string,
+  schema?: string,
+  timeout?: number,
+  async_exec = false,
+): Promise<SnowflakeStatementResponse | SnowflakeQueryResult> {
+  const warehouse = getSnowflakeWarehouse();
+  const defaultDatabase = database || getSnowflakeDatabase();
+  const defaultSchema = schema || getSnowflakeSchema();
+
+  const requestBody = {
+    statement: sqlText,
+    warehouse,
+    database: defaultDatabase,
+    schema: defaultSchema,
+    timeout: timeout || 60,
+    resultSetMetaData: {
+      format: "json",
+    },
+    parameters: {},
+  };
+
+  // For async execution, use the /statements endpoint
+  // For sync execution, use /statements with async=false
+  const endpoint = async_exec
+    ? "/statements?async=true"
+    : "/statements";
+
+  return await snowflakeFetch<SnowflakeStatementResponse | SnowflakeQueryResult>(
+    endpoint,
+    {
+      method: "POST",
+      body: JSON.stringify(requestBody),
+    },
+  );
+}
+
+/**
+ * Get the status and results of a statement
+ */
+export async function getQueryStatus(
+  statementHandle: string,
+): Promise<SnowflakeQueryStatusResponse> {
+  return await snowflakeFetch<SnowflakeQueryStatusResponse>(
+    `/statements/${statementHandle}`,
+  );
+}
+
+/**
+ * Cancel a running statement
+ */
+export async function cancelQuery(statementHandle: string): Promise<void> {
+  await snowflakeFetch(`/statements/${statementHandle}/cancel`, {
+    method: "POST",
+  });
+}
+
+/**
+ * Transform Snowflake result format to more usable JSON objects
+ */
+function transformResults(result: SnowflakeQueryResult): Record<string, unknown>[] {
+  if (!result.data || result.data.length === 0) {
+    return [];
+  }
+
+  const columns = result.resultSetMetaData.rowType.map((col) => col.name);
+
+  return result.data.map((row) => {
+    const obj: Record<string, unknown> = {};
+    columns.forEach((col, index) => {
+      obj[col] = row[index];
+    });
+    return obj;
+  });
+}
+
+/**
+ * Run a SQL query and return results
+ */
+export async function runQuery(
+  sql: string,
+  database?: string,
+  schema?: string,
+  options: {
+    timeout?: number;
+    async?: boolean;
+  } = {},
+): Promise<{
+  columns: Array<{ name: string; type: string; nullable: boolean }>;
+  rows: Record<string, unknown>[];
+  rowCount: number;
+  statementHandle?: string;
+}> {
+  const result = await submitStatement(
+    sql,
+    database,
+    schema,
+    options.timeout,
+    options.async,
+  );
+
+  // Handle async execution
+  if ("statementHandle" in result && !("data" in result)) {
+    return {
+      columns: [],
+      rows: [],
+      rowCount: 0,
+      statementHandle: result.statementHandle,
+    };
+  }
+
+  // Handle synchronous result
+  const queryResult = result as SnowflakeQueryResult;
+
+  const columns = queryResult.resultSetMetaData.rowType.map((col) => ({
+    name: col.name,
+    type: col.type,
+    nullable: col.nullable,
+  }));
+
+  const rows = transformResults(queryResult);
+
+  return {
+    columns,
+    rows,
+    rowCount: queryResult.resultSetMetaData.numRows,
+    statementHandle: queryResult.statementHandle,
+  };
+}
+
+/**
+ * List all databases in the account
+ */
+export async function listDatabases(): Promise<DatabaseInfo[]> {
+  const result = await runQuery("SHOW DATABASES");
+  return result.rows as DatabaseInfo[];
+}
+
+/**
+ * List all schemas in a database
+ */
+export async function listSchemas(database: string): Promise<SchemaInfo[]> {
+  const result = await runQuery(`SHOW SCHEMAS IN DATABASE ${database}`);
+  return result.rows as SchemaInfo[];
+}
+
+/**
+ * List all tables in a database schema
+ */
+export async function listTables(
+  database: string,
+  schema: string,
+): Promise<TableInfo[]> {
+  const result = await runQuery(
+    `SHOW TABLES IN ${database}.${schema}`,
+  );
+  return result.rows as TableInfo[];
+}
+
+/**
+ * Get detailed information about a table's columns
+ */
+export async function describeTable(
+  database: string,
+  schema: string,
+  table: string,
+): Promise<{
+  columns: ColumnInfo[];
+  primaryKeys: string[];
+}> {
+  const result = await runQuery(
+    `DESCRIBE TABLE ${database}.${schema}.${table}`,
+  );
+
+  const columns = result.rows as ColumnInfo[];
+  const primaryKeys = columns
+    .filter((col) => col.primary_key === "Y")
+    .map((col) => col.name);
+
+  return {
+    columns,
+    primaryKeys,
+  };
+}
+
+/**
+ * Get table row count
+ */
+export async function getTableRowCount(
+  database: string,
+  schema: string,
+  table: string,
+): Promise<number> {
+  const result = await runQuery(
+    `SELECT COUNT(*) as count FROM ${database}.${schema}.${table}`,
+  );
+
+  if (result.rows.length > 0 && "count" in result.rows[0]) {
+    return Number(result.rows[0].count);
+  }
+
+  return 0;
+}
+
+/**
+ * Get current Snowflake version and session info
+ */
+export async function getSessionInfo(): Promise<{
+  version: string;
+  warehouse: string;
+  database?: string;
+  schema?: string;
+  user: string;
+  role?: string;
+}> {
+  const result = await runQuery(`
+    SELECT
+      CURRENT_VERSION() as version,
+      CURRENT_WAREHOUSE() as warehouse,
+      CURRENT_DATABASE() as database,
+      CURRENT_SCHEMA() as schema,
+      CURRENT_USER() as user,
+      CURRENT_ROLE() as role
+  `);
+
+  if (result.rows.length === 0) {
+    throw new Error("Failed to get session info");
+  }
+
+  return result.rows[0] as {
+    version: string;
+    warehouse: string;
+    database?: string;
+    schema?: string;
+    user: string;
+    role?: string;
+  };
+}

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

@@ -0,0 +1,77 @@
+// In-memory configuration store for development
+// For production, replace with a secure database-backed implementation
+
+interface SnowflakeConfig {
+  account: string;
+  username: string;
+  password: string;
+  warehouse: string;
+  database?: string;
+  schema?: string;
+}
+
+let configStore: SnowflakeConfig | null = null;
+
+export function setSnowflakeConfig(config: SnowflakeConfig): void {
+  configStore = config;
+}
+
+export function getSnowflakeAccount(): string {
+  if (!configStore?.account) {
+    throw new Error(
+      "Snowflake account not configured. Please set SNOWFLAKE_ACCOUNT environment variable.",
+    );
+  }
+  return configStore.account;
+}
+
+export function getSnowflakeUsername(): string {
+  if (!configStore?.username) {
+    throw new Error(
+      "Snowflake username not configured. Please set SNOWFLAKE_USERNAME environment variable.",
+    );
+  }
+  return configStore.username;
+}
+
+export function getSnowflakePassword(): string {
+  if (!configStore?.password) {
+    throw new Error(
+      "Snowflake password not configured. Please set SNOWFLAKE_PASSWORD environment variable.",
+    );
+  }
+  return configStore.password;
+}
+
+export function getSnowflakeWarehouse(): string {
+  if (!configStore?.warehouse) {
+    throw new Error(
+      "Snowflake warehouse not configured. Please set SNOWFLAKE_WAREHOUSE environment variable.",
+    );
+  }
+  return configStore.warehouse;
+}
+
+export function getSnowflakeDatabase(): string | undefined {
+  return configStore?.database;
+}
+
+export function getSnowflakeSchema(): string {
+  return configStore?.schema || "PUBLIC";
+}
+
+export function clearConfig(): void {
+  configStore = null;
+}
+
+export function isConfigured(): boolean {
+  return configStore !== null &&
+    !!configStore.account &&
+    !!configStore.username &&
+    !!configStore.password &&
+    !!configStore.warehouse;
+}
+
+export function getConfig(): SnowflakeConfig | null {
+  return configStore;
+}

package/dist/integrations/stripe/connector.json

@@ -0,0 +1,97 @@
+{
+  "name": "stripe",
+  "displayName": "Stripe",
+  "icon": "stripe.svg",
+  "description": "Access Stripe payment data, customers, subscriptions, and balance information",
+  "auth": {
+    "type": "api-key",
+    "keyName": "STRIPE_SECRET_KEY",
+    "headerName": "Authorization",
+    "headerPrefix": "Bearer",
+    "requiredApis": [
+      {
+        "name": "Stripe API",
+        "enableUrl": "https://dashboard.stripe.com/apikeys"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "STRIPE_SECRET_KEY",
+      "description": "Stripe Secret Key (starts with sk_)",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://dashboard.stripe.com/apikeys"
+    },
+    {
+      "name": "STRIPE_WEBHOOK_SECRET",
+      "description": "Stripe Webhook Secret (optional, for webhook verification)",
+      "required": false,
+      "sensitive": true,
+      "docsUrl": "https://dashboard.stripe.com/webhooks"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-customers",
+      "name": "List Customers",
+      "description": "List Stripe customers with optional filtering",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-customer",
+      "name": "Get Customer",
+      "description": "Retrieve detailed information about a specific customer",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-payments",
+      "name": "List Payments",
+      "description": "List payment intents with optional status filtering",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-balance",
+      "name": "Get Balance",
+      "description": "Retrieve the current account balance",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-subscriptions",
+      "name": "List Subscriptions",
+      "description": "List subscriptions with optional status filtering",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "check-balance",
+      "title": "Check account balance",
+      "prompt": "Check my Stripe account balance and provide a summary of available and pending funds.",
+      "category": "finance",
+      "icon": "currency"
+    },
+    {
+      "id": "recent-payments",
+      "title": "Recent payments",
+      "prompt": "Show me the most recent successful payments in my Stripe account.",
+      "category": "finance",
+      "icon": "payment"
+    },
+    {
+      "id": "customer-overview",
+      "title": "Customer overview",
+      "prompt": "Give me an overview of my Stripe customers including total count and recent additions.",
+      "category": "analytics",
+      "icon": "users"
+    },
+    {
+      "id": "subscription-status",
+      "title": "Subscription status",
+      "prompt": "Show me the status of all active subscriptions and any that are expiring soon.",
+      "category": "analytics",
+      "icon": "repeat"
+    }
+  ],
+  "suggestedWith": ["slack", "email", "analytics"]
+}

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

@@ -0,0 +1,6 @@
+# Stripe Integration
+# Get your API keys at https://dashboard.stripe.com/apikeys
+# Use test keys (sk_test_...) for development, live keys (sk_live_...) for production
+
+STRIPE_SECRET_KEY=sk_test_your_secret_key_here
+STRIPE_WEBHOOK_SECRET=whsec_your_webhook_secret_here

package/dist/integrations/stripe/files/ai/tools/get-balance.ts

@@ -0,0 +1,28 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatAmount, getBalance } from "../../lib/stripe-client.ts";
+
+export default tool({
+  id: "get-balance",
+  description: "Retrieve the current Stripe account balance including available and pending funds.",
+  inputSchema: z.object({}),
+  async execute() {
+    const balance = await getBalance();
+
+    return {
+      livemode: balance.livemode,
+      available: balance.available.map((bal) => ({
+        amount: formatAmount(bal.amount, bal.currency),
+        amountRaw: bal.amount,
+        currency: bal.currency,
+        sourceTypes: bal.source_types,
+      })),
+      pending: balance.pending.map((bal) => ({
+        amount: formatAmount(bal.amount, bal.currency),
+        amountRaw: bal.amount,
+        currency: bal.currency,
+        sourceTypes: bal.source_types,
+      })),
+    };
+  },
+});

package/dist/integrations/stripe/files/ai/tools/get-customer.ts

@@ -0,0 +1,26 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatDate, getCustomer } from "../../lib/stripe-client.ts";
+
+export default tool({
+  id: "get-customer",
+  description: "Retrieve detailed information about a specific Stripe customer by their ID.",
+  inputSchema: z.object({
+    customerId: z.string().describe("The Stripe customer ID (starts with cus_)"),
+  }),
+  async execute({ customerId }) {
+    const customer = await getCustomer(customerId);
+
+    return {
+      id: customer.id,
+      email: customer.email,
+      name: customer.name,
+      description: customer.description,
+      created: formatDate(customer.created),
+      balance: customer.balance,
+      currency: customer.currency,
+      defaultSource: customer.default_source,
+      metadata: customer.metadata,
+    };
+  },
+});

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

@@ -0,0 +1,42 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatDate, listCustomers } from "../../lib/stripe-client.ts";
+
+export default tool({
+  id: "list-customers",
+  description: "List Stripe customers. Supports filtering by email and creation date range.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(100).default(10).describe(
+      "Maximum number of customers to retrieve",
+    ),
+    email: z.string().email().optional().describe("Filter by customer email address"),
+    createdAfter: z.number().optional().describe(
+      "Filter customers created after this Unix timestamp",
+    ),
+    createdBefore: z.number().optional().describe(
+      "Filter customers created before this Unix timestamp",
+    ),
+  }),
+  async execute({ limit, email, createdAfter, createdBefore }) {
+    const created: { gte?: number; lte?: number } | undefined = createdAfter || createdBefore
+      ? { gte: createdAfter, lte: createdBefore }
+      : undefined;
+
+    const customers = await listCustomers({
+      limit,
+      email,
+      created,
+    });
+
+    return customers.map((customer) => ({
+      id: customer.id,
+      email: customer.email,
+      name: customer.name,
+      description: customer.description,
+      created: formatDate(customer.created),
+      balance: customer.balance,
+      currency: customer.currency,
+      metadata: customer.metadata,
+    }));
+  },
+});

package/dist/integrations/stripe/files/ai/tools/list-payments.ts

@@ -0,0 +1,45 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatAmount, formatDate, listPaymentIntents } from "../../lib/stripe-client.ts";
+
+export default tool({
+  id: "list-payments",
+  description:
+    "List Stripe payment intents. Supports filtering by customer and creation date range.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(100).default(10).describe(
+      "Maximum number of payment intents to retrieve",
+    ),
+    customerId: z.string().optional().describe("Filter by customer ID (starts with cus_)"),
+    createdAfter: z.number().optional().describe(
+      "Filter payments created after this Unix timestamp",
+    ),
+    createdBefore: z.number().optional().describe(
+      "Filter payments created before this Unix timestamp",
+    ),
+  }),
+  async execute({ limit, customerId, createdAfter, createdBefore }) {
+    const created: { gte?: number; lte?: number } | undefined = createdAfter || createdBefore
+      ? { gte: createdAfter, lte: createdBefore }
+      : undefined;
+
+    const payments = await listPaymentIntents({
+      limit,
+      customer: customerId,
+      created,
+    });
+
+    return payments.map((payment) => ({
+      id: payment.id,
+      amount: formatAmount(payment.amount, payment.currency),
+      amountRaw: payment.amount,
+      currency: payment.currency,
+      status: payment.status,
+      customer: payment.customer,
+      description: payment.description,
+      receiptEmail: payment.receipt_email,
+      created: formatDate(payment.created),
+      metadata: payment.metadata,
+    }));
+  },
+});