veryfront 0.0.49 → 0.0.51

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,
+});

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

@@ -0,0 +1,345 @@
+import { getAccessToken } from "./token-store.ts";
+
+const GRAPH_API_BASE = "https://graph.microsoft.com/v1.0";
+
+interface GraphResponse<T> {
+  "@odata.context"?: string;
+  "@odata.nextLink"?: string;
+  value?: T[];
+}
+
+export interface TeamsChat {
+  id: string;
+  topic: string | null;
+  createdDateTime: string;
+  lastUpdatedDateTime: string;
+  chatType: "oneOnOne" | "group" | "meeting";
+  webUrl?: string;
+  members?: ChatMember[];
+}
+
+export interface ChatMember {
+  "@odata.type": string;
+  id: string;
+  displayName?: string;
+  userId?: string;
+  email?: string;
+}
+
+export interface ChatMessage {
+  id: string;
+  messageType: "message" | "chatEvent" | "typing";
+  createdDateTime: string;
+  lastModifiedDateTime?: string;
+  deletedDateTime?: string;
+  subject?: string | null;
+  summary?: string | null;
+  importance: "normal" | "high" | "urgent";
+  locale?: string;
+  from: {
+    user?: {
+      id: string;
+      displayName?: string;
+      userIdentityType?: string;
+    };
+  };
+  body: {
+    contentType: "text" | "html";
+    content: string;
+  };
+  attachments?: Array<{
+    id: string;
+    contentType: string;
+    contentUrl?: string;
+    content?: string;
+    name?: string;
+  }>;
+  mentions?: Array<{
+    id: number;
+    mentionText: string;
+    mentioned: {
+      user: {
+        id: string;
+        displayName?: string;
+      };
+    };
+  }>;
+  reactions?: Array<{
+    reactionType: string;
+    createdDateTime: string;
+    user: {
+      id: string;
+      displayName?: string;
+    };
+  }>;
+}
+
+export interface Team {
+  id: string;
+  displayName: string;
+  description?: string;
+  createdDateTime?: string;
+  webUrl?: string;
+  isArchived?: boolean;
+  visibility?: "private" | "public";
+}
+
+export interface Channel {
+  id: string;
+  displayName: string;
+  description?: string;
+  email?: string;
+  webUrl?: string;
+  membershipType?: "standard" | "private" | "shared";
+  createdDateTime?: string;
+}
+
+async function graphFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Microsoft Teams. Please connect your account.");
+  }
+
+  const url = endpoint.startsWith("http") ? endpoint : `${GRAPH_API_BASE}${endpoint}`;
+
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Microsoft Graph API error: ${response.status} ${
+        error.error?.message || response.statusText
+      }`,
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * List recent chats for the authenticated user
+ */
+export async function listChats(options?: {
+  limit?: number;
+  expand?: string[];
+}): Promise<TeamsChat[]> {
+  const params = new URLSearchParams();
+  if (options?.limit) {
+    params.set("$top", options.limit.toString());
+  }
+  if (options?.expand) {
+    params.set("$expand", options.expand.join(","));
+  }
+
+  const queryString = params.toString();
+  const endpoint = `/me/chats${queryString ? `?${queryString}` : ""}`;
+
+  const response = await graphFetch<GraphResponse<TeamsChat>>(endpoint);
+  return response.value || [];
+}
+
+/**
+ * Get messages from a specific chat
+ */
+export async function getChatMessages(
+  chatId: string,
+  options?: {
+    limit?: number;
+    orderBy?: string;
+  },
+): Promise<ChatMessage[]> {
+  const params = new URLSearchParams();
+  if (options?.limit) {
+    params.set("$top", options.limit.toString());
+  }
+  if (options?.orderBy) {
+    params.set("$orderby", options.orderBy);
+  } else {
+    params.set("$orderby", "createdDateTime desc");
+  }
+
+  const queryString = params.toString();
+  const endpoint = `/me/chats/${chatId}/messages${queryString ? `?${queryString}` : ""}`;
+
+  const response = await graphFetch<GraphResponse<ChatMessage>>(endpoint);
+  return response.value || [];
+}
+
+/**
+ * Send a message to a chat
+ */
+export function sendChatMessage(
+  chatId: string,
+  content: string,
+  contentType: "text" | "html" = "text",
+): Promise<ChatMessage> {
+  const endpoint = `/me/chats/${chatId}/messages`;
+
+  return graphFetch<ChatMessage>(endpoint, {
+    method: "POST",
+    body: JSON.stringify({
+      body: {
+        contentType,
+        content,
+      },
+    }),
+  });
+}
+
+/**
+ * List all teams the user is a member of
+ */
+export async function listTeams(options?: {
+  limit?: number;
+}): Promise<Team[]> {
+  const params = new URLSearchParams();
+  if (options?.limit) {
+    params.set("$top", options.limit.toString());
+  }
+
+  const queryString = params.toString();
+  const endpoint = `/me/joinedTeams${queryString ? `?${queryString}` : ""}`;
+
+  const response = await graphFetch<GraphResponse<Team>>(endpoint);
+  return response.value || [];
+}
+
+/**
+ * List channels in a team
+ */
+export async function listChannels(
+  teamId: string,
+  options?: {
+    limit?: number;
+  },
+): Promise<Channel[]> {
+  const params = new URLSearchParams();
+  if (options?.limit) {
+    params.set("$top", options.limit.toString());
+  }
+
+  const queryString = params.toString();
+  const endpoint = `/teams/${teamId}/channels${queryString ? `?${queryString}` : ""}`;
+
+  const response = await graphFetch<GraphResponse<Channel>>(endpoint);
+  return response.value || [];
+}
+
+/**
+ * Send a message to a team channel
+ */
+export function sendChannelMessage(
+  teamId: string,
+  channelId: string,
+  content: string,
+  contentType: "text" | "html" = "text",
+  subject?: string,
+): Promise<ChatMessage> {
+  const endpoint = `/teams/${teamId}/channels/${channelId}/messages`;
+
+  const body: Record<string, unknown> = {
+    body: {
+      contentType,
+      content,
+    },
+  };
+
+  if (subject) {
+    body.subject = subject;
+  }
+
+  return graphFetch<ChatMessage>(endpoint, {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+}
+
+/**
+ * Get channel messages
+ */
+export async function getChannelMessages(
+  teamId: string,
+  channelId: string,
+  options?: {
+    limit?: number;
+    orderBy?: string;
+  },
+): Promise<ChatMessage[]> {
+  const params = new URLSearchParams();
+  if (options?.limit) {
+    params.set("$top", options.limit.toString());
+  }
+  if (options?.orderBy) {
+    params.set("$orderby", options.orderBy);
+  } else {
+    params.set("$orderby", "createdDateTime desc");
+  }
+
+  const queryString = params.toString();
+  const endpoint = `/teams/${teamId}/channels/${channelId}/messages${
+    queryString ? `?${queryString}` : ""
+  }`;
+
+  const response = await graphFetch<GraphResponse<ChatMessage>>(endpoint);
+  return response.value || [];
+}
+
+/**
+ * Get current user's profile
+ */
+export function getCurrentUser(): Promise<{
+  id: string;
+  displayName: string;
+  mail?: string;
+  userPrincipalName?: string;
+}> {
+  return graphFetch("/me");
+}
+
+/**
+ * Helper to format chat display name
+ */
+export function getChatDisplayName(chat: TeamsChat): string {
+  if (chat.topic) {
+    return chat.topic;
+  }
+
+  if (chat.members && chat.members.length > 0) {
+    const memberNames = chat.members
+      .map((m) => m.displayName)
+      .filter(Boolean)
+      .join(", ");
+    return memberNames || "Unnamed Chat";
+  }
+
+  return chat.chatType === "oneOnOne" ? "Direct Chat" : "Group Chat";
+}
+
+/**
+ * Helper to extract plain text from message body
+ */
+export function getPlainTextContent(message: ChatMessage): string {
+  if (message.body.contentType === "text") {
+    return message.body.content;
+  }
+
+  // Basic HTML stripping for html content
+  return message.body.content
+    .replace(/<[^>]*>/g, "")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .trim();
+}