veryfront 0.0.48 → 0.0.50

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

@@ -0,0 +1,47 @@
+// In-memory API key store for development
+// For production, replace with a database-backed implementation
+
+interface SupabaseConfig {
+  url: string;
+  anonKey: string;
+  serviceKey: string;
+}
+
+let configStore: SupabaseConfig | null = null;
+
+export function setSupabaseConfig(config: SupabaseConfig): void {
+  configStore = config;
+}
+
+export function getSupabaseUrl(): string {
+  if (!configStore?.url) {
+    throw new Error("Supabase URL not configured. Please set SUPABASE_URL environment variable.");
+  }
+  return configStore.url;
+}
+
+export function getAnonKey(): string {
+  if (!configStore?.anonKey) {
+    throw new Error(
+      "Supabase anon key not configured. Please set SUPABASE_ANON_KEY environment variable.",
+    );
+  }
+  return configStore.anonKey;
+}
+
+export function getServiceKey(): string {
+  if (!configStore?.serviceKey) {
+    throw new Error(
+      "Supabase service key not configured. Please set SUPABASE_SERVICE_KEY environment variable.",
+    );
+  }
+  return configStore.serviceKey;
+}
+
+export function clearConfig(): void {
+  configStore = null;
+}
+
+export function isConfigured(): boolean {
+  return configStore !== null;
+}

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)

package/dist/integrations/teams/connector.json

@@ -0,0 +1,99 @@
+{
+  "name": "teams",
+  "displayName": "Microsoft Teams",
+  "icon": "teams.svg",
+  "description": "Send messages and manage Teams chats and channels",
+  "auth": {
+    "type": "oauth2",
+    "provider": "microsoft",
+    "authorizationUrl": "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+    "tokenUrl": "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+    "scopes": [
+      "Chat.Read",
+      "Chat.ReadWrite",
+      "ChannelMessage.Send",
+      "Team.ReadBasic.All",
+      "offline_access"
+    ],
+    "callbackPath": "/api/auth/teams/callback",
+    "tokenAuthMethod": "body",
+    "requiredApis": [
+      {
+        "name": "Microsoft Graph API",
+        "enableUrl": "https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "MICROSOFT_CLIENT_ID",
+      "description": "Microsoft Azure App Client ID (Application ID)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade"
+    },
+    {
+      "name": "MICROSOFT_CLIENT_SECRET",
+      "description": "Microsoft Azure App Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-chats",
+      "name": "List Chats",
+      "description": "List recent Teams chats",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-messages",
+      "name": "Get Messages",
+      "description": "Get messages from a specific chat",
+      "requiresWrite": false
+    },
+    {
+      "id": "send-message",
+      "name": "Send Message",
+      "description": "Send a message to a chat or channel",
+      "requiresWrite": true
+    },
+    {
+      "id": "list-teams",
+      "name": "List Teams",
+      "description": "List all joined Teams",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-channels",
+      "name": "List Channels",
+      "description": "List channels in a specific Team",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "check-messages",
+      "title": "Check my messages",
+      "prompt": "Check my recent Teams messages and summarize any important conversations or action items.",
+      "category": "communication",
+      "icon": "message"
+    },
+    {
+      "id": "send-update",
+      "title": "Send team update",
+      "prompt": "Send a status update message to a specific Teams channel about project progress.",
+      "category": "communication",
+      "icon": "send"
+    },
+    {
+      "id": "find-conversation",
+      "title": "Find a conversation",
+      "prompt": "Search through my Teams chats to find discussions about a specific topic.",
+      "category": "communication",
+      "icon": "search"
+    }
+  ],
+  "suggestedWith": ["outlook", "slack", "calendar"]
+}

package/dist/integrations/teams/files/ai/tools/get-messages.ts

@@ -0,0 +1,55 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getChatMessages, getPlainTextContent } from "../../lib/teams-client.ts";
+
+export default tool({
+  id: "get-messages",
+  description:
+    "Get messages from a specific Microsoft Teams chat. Returns message content, sender information, and timestamps. Use list-chats first to get chat IDs.",
+  inputSchema: z.object({
+    chatId: z.string().describe("The ID of the chat to get messages from"),
+    limit: z.number().min(1).max(50).default(20).describe(
+      "Maximum number of messages to return (1-50)",
+    ),
+    includeHtml: z.boolean().default(false).describe(
+      "Include HTML formatted content in addition to plain text",
+    ),
+  }),
+  async execute({ chatId, limit, includeHtml }) {
+    const messages = await getChatMessages(chatId, {
+      limit,
+      orderBy: "createdDateTime desc",
+    });
+
+    return messages
+      .filter((msg) => msg.messageType === "message") // Filter out typing indicators and events
+      .map((msg) => ({
+        id: msg.id,
+        content: getPlainTextContent(msg),
+        htmlContent: includeHtml ? msg.body.content : undefined,
+        contentType: msg.body.contentType,
+        sender: {
+          id: msg.from.user?.id,
+          displayName: msg.from.user?.displayName,
+        },
+        createdAt: msg.createdDateTime,
+        lastModified: msg.lastModifiedDateTime,
+        importance: msg.importance,
+        subject: msg.subject,
+        hasAttachments: msg.attachments && msg.attachments.length > 0,
+        attachmentCount: msg.attachments?.length || 0,
+        attachments: msg.attachments?.map((att) => ({
+          id: att.id,
+          name: att.name,
+          contentType: att.contentType,
+          contentUrl: att.contentUrl,
+        })),
+        mentions: msg.mentions?.map((mention) => ({
+          text: mention.mentionText,
+          userId: mention.mentioned.user.id,
+          displayName: mention.mentioned.user.displayName,
+        })),
+        reactionCount: msg.reactions?.length || 0,
+      }));
+  },
+});

package/dist/integrations/teams/files/ai/tools/list-channels.ts

@@ -0,0 +1,28 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listChannels } from "../../lib/teams-client.ts";
+
+export default tool({
+  id: "list-channels",
+  description:
+    "List all channels in a specific Microsoft Team. Use list-teams first to get team IDs. Returns channel IDs, names, descriptions, and types.",
+  inputSchema: z.object({
+    teamId: z.string().describe("The ID of the team to list channels from"),
+    limit: z.number().min(1).max(50).default(25).describe(
+      "Maximum number of channels to return (1-50)",
+    ),
+  }),
+  async execute({ teamId, limit }) {
+    const channels = await listChannels(teamId, { limit });
+
+    return channels.map((channel) => ({
+      id: channel.id,
+      name: channel.displayName,
+      description: channel.description,
+      email: channel.email,
+      webUrl: channel.webUrl,
+      membershipType: channel.membershipType,
+      createdAt: channel.createdDateTime,
+    }));
+  },
+});

package/dist/integrations/teams/files/ai/tools/list-chats.ts

@@ -0,0 +1,41 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getChatDisplayName, listChats } from "../../lib/teams-client.ts";
+
+export default tool({
+  id: "list-chats",
+  description:
+    "List recent Microsoft Teams chats for the authenticated user. Returns chat IDs, names, types, and last updated timestamps.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(50).default(20).describe(
+      "Maximum number of chats to return (1-50)",
+    ),
+    expandMembers: z.boolean().default(false).describe("Include chat member information"),
+  }),
+  async execute({ limit, expandMembers }) {
+    const expand = expandMembers ? ["members"] : undefined;
+
+    const chats = await listChats({
+      limit,
+      expand,
+    });
+
+    return chats.map((chat) => ({
+      id: chat.id,
+      name: getChatDisplayName(chat),
+      type: chat.chatType,
+      topic: chat.topic,
+      lastUpdated: chat.lastUpdatedDateTime,
+      created: chat.createdDateTime,
+      webUrl: chat.webUrl,
+      memberCount: chat.members?.length,
+      members: expandMembers
+        ? chat.members?.map((m) => ({
+          id: m.id,
+          displayName: m.displayName,
+          email: m.email,
+        }))
+        : undefined,
+    }));
+  },
+});

package/dist/integrations/teams/files/ai/tools/list-teams.ts

@@ -0,0 +1,27 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listTeams } from "../../lib/teams-client.ts";
+
+export default tool({
+  id: "list-teams",
+  description:
+    "List all Microsoft Teams that the authenticated user is a member of. Returns team IDs, names, descriptions, and metadata.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(50).default(25).describe(
+      "Maximum number of teams to return (1-50)",
+    ),
+  }),
+  async execute({ limit }) {
+    const teams = await listTeams({ limit });
+
+    return teams.map((team) => ({
+      id: team.id,
+      name: team.displayName,
+      description: team.description,
+      visibility: team.visibility,
+      isArchived: team.isArchived,
+      createdAt: team.createdDateTime,
+      webUrl: team.webUrl,
+    }));
+  },
+});

package/dist/integrations/teams/files/ai/tools/send-message.ts

@@ -0,0 +1,61 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { sendChannelMessage, sendChatMessage } from "../../lib/teams-client.ts";
+
+export default tool({
+  id: "send-message",
+  description:
+    "Send a message to a Microsoft Teams chat or channel. For chats, use the chatId. For channels, use both teamId and channelId.",
+  inputSchema: z.object({
+    chatId: z.string().optional().describe(
+      "The ID of the chat to send the message to (use this for direct/group chats)",
+    ),
+    teamId: z.string().optional().describe(
+      "The ID of the team (use with channelId for channel messages)",
+    ),
+    channelId: z.string().optional().describe(
+      "The ID of the channel (use with teamId for channel messages)",
+    ),
+    content: z.string().min(1).describe("The message content to send"),
+    contentType: z.enum(["text", "html"]).default("text").describe("Content format: text or html"),
+    subject: z.string().optional().describe("Subject line (only for channel messages)"),
+  }).refine(
+    (data) =>
+      (data.chatId && !data.teamId && !data.channelId) ||
+      (!data.chatId && data.teamId && data.channelId),
+    {
+      message: "Either provide chatId OR both teamId and channelId",
+    },
+  ),
+  async execute({ chatId, teamId, channelId, content, contentType, subject }) {
+    // Send to chat
+    if (chatId) {
+      const message = await sendChatMessage(chatId, content, contentType);
+      return {
+        success: true,
+        messageId: message.id,
+        type: "chat",
+        chatId,
+        createdAt: message.createdDateTime,
+        content: message.body.content,
+      };
+    }
+
+    // Send to channel
+    if (teamId && channelId) {
+      const message = await sendChannelMessage(teamId, channelId, content, contentType, subject);
+      return {
+        success: true,
+        messageId: message.id,
+        type: "channel",
+        teamId,
+        channelId,
+        subject,
+        createdAt: message.createdDateTime,
+        content: message.body.content,
+      };
+    }
+
+    throw new Error("Invalid parameters: provide either chatId or both teamId and channelId");
+  },
+});

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

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

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

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