veryfront 0.0.49 → 0.0.50

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

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

@@ -0,0 +1,5 @@
+/**
+ * Teams Token Store
+ */
+
+export { memoryTokenStore as tokenStore, type OAuthTokens, type TokenStore } from "veryfront/oauth";

package/dist/integrations/trello/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "trello",
+  "displayName": "Trello",
+  "icon": "trello.svg",
+  "description": "Manage boards, lists, and cards in Trello",
+  "auth": {
+    "type": "oauth2",
+    "provider": "trello",
+    "authorizationUrl": "https://trello.com/1/authorize",
+    "tokenUrl": "https://trello.com/1/OAuthGetAccessToken",
+    "scopes": ["read", "write"],
+    "callbackPath": "/api/auth/trello/callback",
+    "requiredApis": [
+      {
+        "name": "Trello Developer Portal",
+        "enableUrl": "https://trello.com/app-key"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "TRELLO_CLIENT_ID",
+      "description": "Trello API Key",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developer.atlassian.com/cloud/trello/guides/rest-api/authorization/"
+    },
+    {
+      "name": "TRELLO_CLIENT_SECRET",
+      "description": "Trello OAuth Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developer.atlassian.com/cloud/trello/guides/rest-api/authorization/"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-boards",
+      "name": "List Boards",
+      "description": "List all boards accessible to the user",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-cards",
+      "name": "List Cards",
+      "description": "List cards in a board or list",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-card",
+      "name": "Get Card",
+      "description": "Get details of a specific card",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-card",
+      "name": "Create Card",
+      "description": "Create a new card in a list",
+      "requiresWrite": true
+    },
+    {
+      "id": "update-card",
+      "name": "Update Card",
+      "description": "Update an existing card",
+      "requiresWrite": true
+    }
+  ],
+  "prompts": [
+    {
+      "id": "my-boards",
+      "title": "Show my boards",
+      "prompt": "List all my Trello boards with their lists and card counts.",
+      "category": "productivity",
+      "icon": "grid"
+    },
+    {
+      "id": "create-card",
+      "title": "Create a card",
+      "prompt": "Create a new card with a title, description, and due date.",
+      "category": "productivity",
+      "icon": "plus"
+    }
+  ],
+  "suggestedWith": ["slack", "asana", "notion"]
+}

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

@@ -0,0 +1,4 @@
+# Trello OAuth Configuration
+# Get your credentials from https://trello.com/app-key
+TRELLO_CLIENT_ID=your-api-key
+TRELLO_CLIENT_SECRET=your-oauth-secret

package/dist/integrations/trello/files/ai/tools/create-card.ts

@@ -0,0 +1,54 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createCard } from "../../lib/trello-client.ts";
+
+export default tool({
+  id: "create-card",
+  description: "Create a new card in a Trello list.",
+  inputSchema: z.object({
+    listId: z.string().describe("The ID of the list to create the card in"),
+    name: z.string().describe("The name/title of the card"),
+    desc: z.string().optional().describe("Description or details for the card"),
+    due: z.string().optional().describe("Due date in ISO 8601 format (e.g., 2024-12-31T23:59:59.000Z)"),
+    pos: z
+      .union([z.string(), z.number()])
+      .optional()
+      .describe('Position of the card: "top", "bottom", or a positive number'),
+    idMembers: z
+      .array(z.string())
+      .optional()
+      .describe("Array of member IDs to assign to the card"),
+    idLabels: z
+      .array(z.string())
+      .optional()
+      .describe("Array of label IDs to add to the card"),
+  }),
+  async execute({ listId, name, desc, due, pos, idMembers, idLabels }) {
+    const card = await createCard({
+      listId,
+      name,
+      desc,
+      due,
+      pos,
+      idMembers,
+      idLabels,
+    });
+
+    return {
+      success: true,
+      card: {
+        id: card.id,
+        name: card.name,
+        desc: card.desc,
+        url: card.url,
+        idList: card.idList,
+        due: card.due,
+        labels: card.labels.map((label) => ({
+          id: label.id,
+          name: label.name,
+          color: label.color,
+        })),
+      },
+    };
+  },
+});

package/dist/integrations/trello/files/ai/tools/get-card.ts

@@ -0,0 +1,33 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getCard } from "../../lib/trello-client.ts";
+
+export default tool({
+  id: "get-card",
+  description: "Get details of a specific Trello card by its ID.",
+  inputSchema: z.object({
+    cardId: z.string().describe("The ID of the card to retrieve"),
+  }),
+  async execute({ cardId }) {
+    const card = await getCard(cardId);
+
+    return {
+      id: card.id,
+      name: card.name,
+      desc: card.desc,
+      url: card.url,
+      closed: card.closed,
+      idList: card.idList,
+      idBoard: card.idBoard,
+      due: card.due,
+      dueComplete: card.dueComplete,
+      labels: card.labels.map((label) => ({
+        id: label.id,
+        name: label.name,
+        color: label.color,
+      })),
+      memberIds: card.idMembers,
+      lastActivity: card.dateLastActivity,
+    };
+  },
+});

package/dist/integrations/trello/files/ai/tools/list-boards.ts

@@ -0,0 +1,29 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listBoards } from "../../lib/trello-client.ts";
+
+export default tool({
+  id: "list-boards",
+  description: "List all Trello boards accessible to the current user.",
+  inputSchema: z.object({
+    includeArchived: z.boolean().default(false).describe("Include archived/closed boards"),
+    limit: z.number().min(1).max(100).default(20).describe("Maximum number of boards to return"),
+  }),
+  async execute({ includeArchived, limit }) {
+    const boards = await listBoards();
+
+    const filteredBoards = includeArchived
+      ? boards
+      : boards.filter((board) => !board.closed);
+
+    return filteredBoards.slice(0, limit).map((board) => ({
+      id: board.id,
+      name: board.name,
+      desc: board.desc,
+      url: board.url,
+      closed: board.closed,
+      backgroundColor: board.prefs?.backgroundColor,
+      lastActivity: board.dateLastActivity,
+    }));
+  },
+});

package/dist/integrations/trello/files/ai/tools/list-cards.ts

@@ -0,0 +1,52 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listCards } from "../../lib/trello-client.ts";
+
+export default tool({
+  id: "list-cards",
+  description:
+    "List cards from Trello. Can filter by board or list. Provide either boardId or listId.",
+  inputSchema: z.object({
+    boardId: z.string().optional().describe("Board ID to list cards from"),
+    listId: z.string().optional().describe("List ID to list cards from"),
+    includeArchived: z.boolean().default(false).describe("Include archived/closed cards"),
+    limit: z.number().min(1).max(100).default(50).describe("Maximum number of cards to return"),
+  }),
+  async execute({ boardId, listId, includeArchived, limit }) {
+    if (!boardId && !listId) {
+      return {
+        cards: [],
+        message: "Please specify either a boardId or listId",
+      };
+    }
+
+    const cards = await listCards({
+      boardId,
+      listId,
+      limit,
+    });
+
+    const filteredCards = includeArchived
+      ? cards
+      : cards.filter((card) => !card.closed);
+
+    return filteredCards.map((card) => ({
+      id: card.id,
+      name: card.name,
+      desc: card.desc,
+      url: card.url,
+      closed: card.closed,
+      idList: card.idList,
+      idBoard: card.idBoard,
+      due: card.due,
+      dueComplete: card.dueComplete,
+      labels: card.labels.map((label) => ({
+        id: label.id,
+        name: label.name,
+        color: label.color,
+      })),
+      memberIds: card.idMembers,
+      lastActivity: card.dateLastActivity,
+    }));
+  },
+});

package/dist/integrations/trello/files/ai/tools/update-card.ts

@@ -0,0 +1,65 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { updateCard } from "../../lib/trello-client.ts";
+
+export default tool({
+  id: "update-card",
+  description: "Update an existing Trello card.",
+  inputSchema: z.object({
+    cardId: z.string().describe("The ID of the card to update"),
+    name: z.string().optional().describe("New name/title for the card"),
+    desc: z.string().optional().describe("New description or details"),
+    closed: z.boolean().optional().describe("Archive or unarchive the card"),
+    idList: z.string().optional().describe("Move the card to a different list by list ID"),
+    due: z
+      .string()
+      .nullable()
+      .optional()
+      .describe("New due date in ISO 8601 format, or null to remove due date"),
+    dueComplete: z.boolean().optional().describe("Mark the due date as complete or incomplete"),
+    pos: z
+      .union([z.string(), z.number()])
+      .optional()
+      .describe('New position: "top", "bottom", or a positive number'),
+    idMembers: z
+      .array(z.string())
+      .optional()
+      .describe("Array of member IDs to assign to the card (replaces existing)"),
+    idLabels: z
+      .array(z.string())
+      .optional()
+      .describe("Array of label IDs for the card (replaces existing)"),
+  }),
+  async execute({ cardId, name, desc, closed, idList, due, dueComplete, pos, idMembers, idLabels }) {
+    const card = await updateCard(cardId, {
+      name,
+      desc,
+      closed,
+      idList,
+      due,
+      dueComplete,
+      pos,
+      idMembers,
+      idLabels,
+    });
+
+    return {
+      success: true,
+      card: {
+        id: card.id,
+        name: card.name,
+        desc: card.desc,
+        url: card.url,
+        closed: card.closed,
+        idList: card.idList,
+        due: card.due,
+        dueComplete: card.dueComplete,
+        labels: card.labels.map((label) => ({
+          id: label.id,
+          name: label.name,
+          color: label.color,
+        })),
+      },
+    };
+  },
+});

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

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

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

@@ -0,0 +1,7 @@
+/**
+ * Trello OAuth Init
+ */
+
+import { trelloConfig, createOAuthInitHandler } from "veryfront/oauth";
+
+export const GET = createOAuthInitHandler(trelloConfig);