veryfront 0.0.49 → 0.0.51

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

@@ -0,0 +1,64 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { updateRow, updateRows } from "../../lib/supabase-client.ts";
+
+export default tool({
+  id: "update-row",
+  description: "Update rows in a Supabase table. Can update by ID or by custom filter conditions.",
+  inputSchema: z.object({
+    tableName: z.string().describe("The name of the table to update"),
+    id: z.union([z.string(), z.number()]).optional().describe(
+      "The ID of the row to update (if updating a single row by ID)",
+    ),
+    filter: z.record(z.unknown()).optional().describe(
+      'Filter conditions to match rows to update (e.g., {"status": "pending"})',
+    ),
+    data: z.record(z.unknown()).describe("The data to update as key-value pairs"),
+  }),
+  async execute({ tableName, id, filter, data }) {
+    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 update rows",
+        };
+      }
+
+      // Update by ID (single row)
+      if (id) {
+        const result = await updateRow(tableName, id, data);
+        return {
+          success: true,
+          tableName,
+          rowsUpdated: 1,
+          row: result,
+          message: `Successfully updated row with id ${id} in ${tableName}`,
+        };
+      }
+
+      // Update by filter (multiple rows)
+      if (filter) {
+        const results = await updateRows(tableName, filter, data);
+        return {
+          success: true,
+          tableName,
+          rowsUpdated: results.length,
+          rows: results,
+          message: `Successfully updated ${results.length} row(s) in ${tableName}`,
+        };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+
+      return {
+        success: false,
+        tableName,
+        error: errorMessage,
+        message: `Failed to update row(s) in ${tableName}: ${errorMessage}`,
+      };
+    }
+  },
+});

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

@@ -0,0 +1,91 @@
+import { isConfigured, setSupabaseConfig } from "../../../../lib/token-store.ts";
+
+/**
+ * POST /api/auth/supabase
+ * Initialize Supabase configuration with API keys
+ */
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { url, anonKey, serviceKey } = body;
+
+    // Validate required fields
+    if (!url || !anonKey || !serviceKey) {
+      return Response.json(
+        { error: "Missing required fields: url, anonKey, serviceKey" },
+        { status: 400 },
+      );
+    }
+
+    // Validate URL format
+    try {
+      new URL(url);
+    } catch {
+      return Response.json(
+        { error: "Invalid Supabase URL format" },
+        { status: 400 },
+      );
+    }
+
+    // Store configuration
+    setSupabaseConfig({
+      url,
+      anonKey,
+      serviceKey,
+    });
+
+    return Response.json({
+      success: true,
+      message: "Supabase configuration saved successfully",
+    });
+  } catch (error) {
+    console.error("Supabase config error:", error);
+    return Response.json(
+      { error: "Failed to configure Supabase" },
+      { status: 500 },
+    );
+  }
+}
+
+/**
+ * GET /api/auth/supabase
+ * Check if Supabase is configured
+ */
+export function GET() {
+  try {
+    const configured = isConfigured();
+
+    return Response.json({
+      configured,
+      message: configured ? "Supabase is configured" : "Supabase is not configured",
+    });
+  } catch (error) {
+    console.error("Supabase status check error:", error);
+    return Response.json(
+      { error: "Failed to check Supabase status" },
+      { status: 500 },
+    );
+  }
+}
+
+/**
+ * DELETE /api/auth/supabase
+ * Clear Supabase configuration
+ */
+export async function DELETE() {
+  try {
+    const { clearConfig } = await import("../../../../lib/token-store.ts");
+    clearConfig();
+
+    return Response.json({
+      success: true,
+      message: "Supabase configuration cleared",
+    });
+  } catch (error) {
+    console.error("Supabase clear config error:", error);
+    return Response.json(
+      { error: "Failed to clear Supabase configuration" },
+      { status: 500 },
+    );
+  }
+}

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

@@ -0,0 +1,296 @@
+import { getAnonKey, getServiceKey, getSupabaseUrl } from "./token-store.ts";
+
+interface SupabaseResponse<T> {
+  data: T | null;
+  error: {
+    message: string;
+    details?: string;
+    hint?: string;
+    code?: string;
+  } | null;
+}
+
+interface TableInfo {
+  table_name: string;
+  table_schema: string;
+  table_type: string;
+}
+
+interface ColumnInfo {
+  column_name: string;
+  data_type: string;
+  is_nullable: string;
+  column_default: string | null;
+}
+
+interface QueryOptions {
+  select?: string;
+  filter?: Record<string, unknown>;
+  order?: { column: string; ascending?: boolean };
+  limit?: number;
+  offset?: number;
+}
+
+interface SupabaseError extends Error {
+  code?: string;
+  details?: string;
+  hint?: string;
+}
+
+async function supabaseFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+  useServiceRole = true,
+): Promise<T> {
+  const url = getSupabaseUrl();
+  const apiKey = useServiceRole ? getServiceKey() : getAnonKey();
+
+  const response = await fetch(`${url}/rest/v1${endpoint}`, {
+    ...options,
+    headers: {
+      "apikey": apiKey,
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "Prefer": "return=representation",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({})) as SupabaseError;
+    const errorMessage = error.message ||
+      `Supabase API error: ${response.status} ${response.statusText}`;
+    const err: SupabaseError = new Error(errorMessage);
+    err.code = error.code;
+    err.details = error.details;
+    err.hint = error.hint;
+    throw err;
+  }
+
+  // Handle empty responses (like DELETE)
+  const text = await response.text();
+  return text ? JSON.parse(text) : null;
+}
+
+/**
+ * List all tables in the public schema
+ */
+export async function listTables(): Promise<TableInfo[]> {
+  try {
+    const tables = await supabaseFetch<TableInfo[]>(
+      `/rpc/get_tables`,
+      {
+        method: "POST",
+        body: JSON.stringify({}),
+      },
+    );
+    return tables || [];
+  } catch (_error) {
+    // Fallback: query information_schema directly
+    const query =
+      `?select=table_name,table_schema,table_type&table_schema=eq.public&table_type=eq.BASE TABLE`;
+    const tables = await supabaseFetch<TableInfo[]>(`/information_schema.tables${query}`);
+    return tables || [];
+  }
+}
+
+/**
+ * Get columns for a specific table
+ */
+export async function getTableColumns(tableName: string): Promise<ColumnInfo[]> {
+  const query =
+    `?select=column_name,data_type,is_nullable,column_default&table_name=eq.${tableName}&table_schema=eq.public`;
+  const columns = await supabaseFetch<ColumnInfo[]>(`/information_schema.columns${query}`);
+  return columns || [];
+}
+
+/**
+ * Query a table with filters, sorting, and pagination
+ */
+export async function queryTable<T = Record<string, unknown>>(
+  tableName: string,
+  options: QueryOptions = {},
+): Promise<T[]> {
+  const params = new URLSearchParams();
+
+  // Select columns
+  if (options.select) {
+    params.append("select", options.select);
+  } else {
+    params.append("select", "*");
+  }
+
+  // Add filters
+  if (options.filter) {
+    for (const [key, value] of Object.entries(options.filter)) {
+      if (value === null) {
+        params.append(key, "is.null");
+      } else if (typeof value === "string") {
+        params.append(key, `eq.${value}`);
+      } else if (typeof value === "number") {
+        params.append(key, `eq.${value}`);
+      } else if (typeof value === "boolean") {
+        params.append(key, `eq.${value}`);
+      }
+    }
+  }
+
+  // Add ordering
+  if (options.order) {
+    const direction = options.order.ascending === false ? ".desc" : ".asc";
+    params.append("order", `${options.order.column}${direction}`);
+  }
+
+  // Add pagination
+  if (options.limit) {
+    params.append("limit", options.limit.toString());
+  }
+  if (options.offset) {
+    params.append("offset", options.offset.toString());
+  }
+
+  const queryString = params.toString();
+  const results = await supabaseFetch<T[]>(`/${tableName}?${queryString}`);
+  return results || [];
+}
+
+/**
+ * Insert a new row into a table
+ */
+export async function insertRow<T = Record<string, unknown>>(
+  tableName: string,
+  data: Record<string, unknown>,
+): Promise<T> {
+  const result = await supabaseFetch<T[]>(
+    `/${tableName}`,
+    {
+      method: "POST",
+      body: JSON.stringify(data),
+    },
+  );
+
+  if (!result || result.length === 0) {
+    throw new Error("Insert operation did not return data");
+  }
+
+  return result[0];
+}
+
+/**
+ * Update a row in a table by ID
+ */
+export async function updateRow<T = Record<string, unknown>>(
+  tableName: string,
+  id: string | number,
+  data: Record<string, unknown>,
+): Promise<T> {
+  const result = await supabaseFetch<T[]>(
+    `/${tableName}?id=eq.${id}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify(data),
+    },
+  );
+
+  if (!result || result.length === 0) {
+    throw new Error(`No row found with id ${id}`);
+  }
+
+  return result[0];
+}
+
+/**
+ * Update rows in a table with custom filter
+ */
+export async function updateRows<T = Record<string, unknown>>(
+  tableName: string,
+  filter: Record<string, unknown>,
+  data: Record<string, unknown>,
+): Promise<T[]> {
+  const params = new URLSearchParams();
+
+  for (const [key, value] of Object.entries(filter)) {
+    params.append(key, `eq.${value}`);
+  }
+
+  const result = await supabaseFetch<T[]>(
+    `/${tableName}?${params.toString()}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify(data),
+    },
+  );
+
+  return result || [];
+}
+
+/**
+ * Delete a row from a table by ID
+ */
+export async function deleteRow<T = Record<string, unknown>>(
+  tableName: string,
+  id: string | number,
+): Promise<T> {
+  const result = await supabaseFetch<T[]>(
+    `/${tableName}?id=eq.${id}`,
+    {
+      method: "DELETE",
+    },
+  );
+
+  if (!result || result.length === 0) {
+    throw new Error(`No row found with id ${id}`);
+  }
+
+  return result[0];
+}
+
+/**
+ * Delete rows from a table with custom filter
+ */
+export async function deleteRows<T = Record<string, unknown>>(
+  tableName: string,
+  filter: Record<string, unknown>,
+): Promise<T[]> {
+  const params = new URLSearchParams();
+
+  for (const [key, value] of Object.entries(filter)) {
+    params.append(key, `eq.${value}`);
+  }
+
+  const result = await supabaseFetch<T[]>(
+    `/${tableName}?${params.toString()}`,
+    {
+      method: "DELETE",
+    },
+  );
+
+  return result || [];
+}
+
+/**
+ * Execute a raw SQL query using RPC
+ * Note: This requires a stored procedure to be created in your Supabase database
+ */
+export function runRawQuery<T = unknown>(
+  query: string,
+): Promise<T> {
+  return supabaseFetch<T>(
+    "/rpc/execute_sql",
+    {
+      method: "POST",
+      body: JSON.stringify({ query }),
+    },
+  );
+}
+
+/**
+ * Get client instance (for use with @supabase/supabase-js if needed)
+ */
+export function getClient() {
+  return {
+    url: getSupabaseUrl(),
+    anonKey: getAnonKey(),
+    serviceKey: getServiceKey(),
+  };
+}

package/dist/integrations/teams/README.md

@@ -0,0 +1,256 @@
+# Microsoft Teams Integration for Veryfront
+
+This integration enables AI agents to interact with Microsoft Teams, allowing them to read chats, send messages, and manage team channels.
+
+## Features
+
+- **List Chats**: Retrieve recent Teams chats with filtering options
+- **Get Messages**: Read messages from specific chats or channels
+- **Send Messages**: Send messages to chats or team channels
+- **List Teams**: Get all teams the user is a member of
+- **List Channels**: List channels within a specific team
+
+## Setup
+
+### 1. Register an Azure Application
+
+1. Go to the [Azure Portal](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade)
+2. Click "New registration"
+3. Enter a name for your application (e.g., "Veryfront Teams Integration")
+4. Set the redirect URI to: `https://yourdomain.com/api/auth/teams/callback`
+5. Click "Register"
+
+### 2. Configure API Permissions
+
+After registering your app:
+
+1. Go to "API permissions" in the left sidebar
+2. Click "Add a permission"
+3. Select "Microsoft Graph"
+4. Choose "Delegated permissions"
+5. Add the following permissions:
+   - `Chat.Read` - Read user chats
+   - `Chat.ReadWrite` - Read and write user chats
+   - `ChannelMessage.Send` - Send channel messages
+   - `Team.ReadBasic.All` - Read team information
+   - `offline_access` - Maintain access to data
+6. Click "Grant admin consent" if required by your organization
+
+### 3. Create a Client Secret
+
+1. Go to "Certificates & secrets"
+2. Click "New client secret"
+3. Add a description and set expiration
+4. Copy the secret value immediately (it won't be shown again)
+
+### 4. Configure Environment Variables
+
+Add the following to your `.env` file:
+
+```bash
+MICROSOFT_CLIENT_ID=your_application_id_here
+MICROSOFT_CLIENT_SECRET=your_client_secret_here
+```
+
+## Usage
+
+### Authentication
+
+Users need to authenticate with Microsoft Teams before using the tools:
+
+1. Navigate to `/api/auth/teams` in your application
+2. Complete the Microsoft OAuth flow
+3. You'll be redirected back to your application with access granted
+
+### AI Tools
+
+#### list-chats
+
+List recent Teams chats:
+
+```typescript
+{
+  limit: 20,              // Number of chats to return (1-50)
+  expandMembers: false    // Include member information
+}
+```
+
+Returns chat IDs, names, types, and timestamps.
+
+#### get-messages
+
+Get messages from a specific chat:
+
+```typescript
+{
+  chatId: "19:...",       // Chat ID from list-chats
+  limit: 20,              // Number of messages (1-50)
+  includeHtml: false      // Include HTML formatted content
+}
+```
+
+Returns message content, sender info, attachments, and reactions.
+
+#### send-message
+
+Send a message to a chat or channel:
+
+**For Chats:**
+```typescript
+{
+  chatId: "19:...",
+  content: "Hello from the AI!",
+  contentType: "text"     // "text" or "html"
+}
+```
+
+**For Channels:**
+```typescript
+{
+  teamId: "team-id",
+  channelId: "channel-id",
+  content: "Update: Project completed!",
+  contentType: "text",
+  subject: "Project Update"  // Optional
+}
+```
+
+#### list-teams
+
+List all teams the user has joined:
+
+```typescript
+{
+  limit: 25               // Number of teams (1-50)
+}
+```
+
+Returns team IDs, names, descriptions, and metadata.
+
+#### list-channels
+
+List channels in a specific team:
+
+```typescript
+{
+  teamId: "team-id",
+  limit: 25               // Number of channels (1-50)
+}
+```
+
+Returns channel IDs, names, types, and links.
+
+## API Client
+
+The Teams client (`teams-client.ts`) provides typed methods for all Microsoft Graph API operations:
+
+```typescript
+import {
+  listChats,
+  getChatMessages,
+  sendChatMessage,
+  listTeams,
+  listChannels,
+  sendChannelMessage,
+  getChatDisplayName,
+  getPlainTextContent
+} from "./lib/teams-client.ts";
+```
+
+### Key Methods
+
+- `listChats(options)` - List user chats
+- `getChatMessages(chatId, options)` - Get chat messages
+- `sendChatMessage(chatId, content, contentType)` - Send chat message
+- `listTeams(options)` - List joined teams
+- `listChannels(teamId, options)` - List team channels
+- `sendChannelMessage(teamId, channelId, content, contentType, subject)` - Send channel message
+- `getCurrentUser()` - Get current user profile
+
+### Helper Functions
+
+- `getChatDisplayName(chat)` - Format chat display name
+- `getPlainTextContent(message)` - Extract plain text from message
+
+## Token Management
+
+The integration uses an in-memory token store for development. For production:
+
+1. Replace `token-store.ts` with a database-backed implementation
+2. Store tokens securely with encryption
+3. Implement token refresh logic using the `refreshAccessToken()` function in `oauth.ts`
+4. Handle token expiration gracefully
+
+## Security Considerations
+
+- **Scopes**: Only request the minimum required permissions
+- **Token Storage**: Use encrypted database storage in production
+- **Token Refresh**: Implement automatic token refresh before expiration
+- **CSRF Protection**: State parameter is included in OAuth flow
+- **Environment Variables**: Keep client secrets secure and never commit them
+
+## Integration with Other Services
+
+This integration works well with:
+
+- **Outlook**: Shared Microsoft OAuth credentials
+- **Calendar**: Microsoft Calendar integration
+- **Slack**: Cross-platform messaging
+- **Gmail**: Email and chat integration
+
+Set `suggestedWith` in connector.json to recommend related integrations.
+
+## Troubleshooting
+
+### Authentication Fails
+
+- Verify client ID and secret are correct
+- Check redirect URI matches Azure app configuration
+- Ensure required API permissions are granted
+
+### Cannot Read Messages
+
+- Verify `Chat.Read` permission is granted
+- Check user has access to the chat
+- Ensure token hasn't expired
+
+### Cannot Send Messages
+
+- Verify `Chat.ReadWrite` or `ChannelMessage.Send` permissions
+- Check user is a member of the chat/channel
+- Ensure message content is not empty
+
+### Token Expired
+
+- Implement token refresh using `refreshAccessToken()` in `oauth.ts`
+- Store refresh tokens securely
+- Handle 401 responses by triggering re-authentication
+
+## API Limits
+
+Microsoft Graph API has rate limits:
+
+- **Per-app limit**: 2000 requests per second
+- **Per-user limit**: 50 requests per second
+- **Concurrent requests**: 20 per user
+
+Implement exponential backoff and retry logic for production use.
+
+## TypeScript Types
+
+All API responses are fully typed. Key interfaces:
+
+- `TeamsChat` - Chat information
+- `ChatMessage` - Message with content and metadata
+- `Team` - Team information
+- `Channel` - Channel information
+- `ChatMember` - Member information
+
+See `teams-client.ts` for complete type definitions.
+
+## Resources
+
+- [Microsoft Graph Teams API](https://learn.microsoft.com/en-us/graph/api/resources/teams-api-overview)
+- [Azure App Registration](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade)
+- [Microsoft Graph Explorer](https://developer.microsoft.com/en-us/graph/graph-explorer)
+- [OAuth 2.0 Authorization](https://learn.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-auth-code-flow)