veryfront 0.0.49 → 0.0.50

package/dist/integrations/discord/connector.json

@@ -0,0 +1,100 @@
+{
+  "name": "discord",
+  "displayName": "Discord",
+  "icon": "discord.svg",
+  "description": "Read messages, send messages, and interact with Discord servers",
+  "auth": {
+    "type": "oauth2",
+    "provider": "discord",
+    "authorizationUrl": "https://discord.com/api/oauth2/authorize",
+    "tokenUrl": "https://discord.com/api/oauth2/token",
+    "scopes": ["identify", "guilds", "guilds.members.read", "messages.read"],
+    "callbackPath": "/api/auth/discord/callback",
+    "tokenAuthMethod": "body",
+    "requiredApis": [
+      {
+        "name": "Discord Application",
+        "enableUrl": "https://discord.com/developers/applications"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "DISCORD_CLIENT_ID",
+      "description": "Discord OAuth Client ID (from your application)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://discord.com/developers/applications"
+    },
+    {
+      "name": "DISCORD_CLIENT_SECRET",
+      "description": "Discord OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://discord.com/developers/applications"
+    },
+    {
+      "name": "DISCORD_BOT_TOKEN",
+      "description": "Discord Bot Token (optional, for advanced bot features)",
+      "required": false,
+      "sensitive": true,
+      "docsUrl": "https://discord.com/developers/applications"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-guilds",
+      "name": "List Guilds",
+      "description": "List Discord servers (guilds) the user is a member of",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-channels",
+      "name": "List Channels",
+      "description": "List channels in a Discord server",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-messages",
+      "name": "Get Messages",
+      "description": "Get recent messages from a Discord channel",
+      "requiresWrite": false
+    },
+    {
+      "id": "send-message",
+      "name": "Send Message",
+      "description": "Send a message to a Discord channel",
+      "requiresWrite": true
+    },
+    {
+      "id": "get-user",
+      "name": "Get User",
+      "description": "Get information about the authenticated Discord user",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "check-messages",
+      "title": "Check my Discord messages",
+      "prompt": "Check my recent Discord messages across all servers and summarize any important updates or mentions.",
+      "category": "communication",
+      "icon": "message"
+    },
+    {
+      "id": "send-announcement",
+      "title": "Send an announcement",
+      "prompt": "Send an announcement message to a specific Discord channel.",
+      "category": "communication",
+      "icon": "megaphone"
+    },
+    {
+      "id": "list-servers",
+      "title": "List my servers",
+      "prompt": "Show me all the Discord servers I'm a member of with their details.",
+      "category": "communication",
+      "icon": "list"
+    }
+  ],
+  "suggestedWith": ["slack", "github", "notion"]
+}

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

@@ -0,0 +1,12 @@
+# Discord OAuth Configuration
+# Get these from https://discord.com/developers/applications
+
+# Required: Your Discord application's Client ID
+DISCORD_CLIENT_ID=your_client_id_here
+
+# Required: Your Discord application's Client Secret
+DISCORD_CLIENT_SECRET=your_client_secret_here
+
+# Optional: Bot token for advanced bot features
+# Only needed if you want to use bot-specific functionality
+DISCORD_BOT_TOKEN=your_bot_token_here

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

@@ -0,0 +1,55 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatUsername, getMessages } from "../../lib/discord-client.ts";
+
+export default tool({
+  id: "get-messages",
+  description:
+    "Get recent messages from a Discord channel. Returns message content, authors, timestamps, and attachments.",
+  inputSchema: z.object({
+    channelId: z.string().describe("The ID of the Discord channel to get messages from"),
+    limit: z.number().min(1).max(100).default(50).describe(
+      "Maximum number of messages to retrieve (1-100)",
+    ),
+    before: z.string().optional().describe("Get messages before this message ID"),
+    after: z.string().optional().describe("Get messages after this message ID"),
+  }),
+  async execute({ channelId, limit, before, after }) {
+    const messages = await getMessages(channelId, {
+      limit,
+      before,
+      after,
+    });
+
+    return messages.map((message) => ({
+      id: message.id,
+      content: message.content,
+      author: {
+        id: message.author.id,
+        username: formatUsername(message.author),
+        globalName: message.author.global_name,
+        bot: message.author.bot,
+      },
+      timestamp: message.timestamp,
+      editedTimestamp: message.edited_timestamp,
+      pinned: message.pinned,
+      mentions: message.mentions.map((user) => ({
+        id: user.id,
+        username: formatUsername(user),
+      })),
+      attachments: message.attachments.map((attachment) => ({
+        id: attachment.id,
+        filename: attachment.filename,
+        url: attachment.url,
+        size: attachment.size,
+        contentType: attachment.content_type,
+      })),
+      hasEmbeds: message.embeds.length > 0,
+      reactions: message.reactions?.map((reaction) => ({
+        emoji: reaction.emoji.name,
+        count: reaction.count,
+        meReacted: reaction.me,
+      })),
+    }));
+  },
+});

package/dist/integrations/discord/files/ai/tools/get-user.ts

@@ -0,0 +1,32 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatUsername, getAvatarUrl, getCurrentUser } from "../../lib/discord-client.ts";
+
+export default tool({
+  id: "get-user",
+  description:
+    "Get information about the authenticated Discord user. Returns username, ID, avatar, and account details.",
+  inputSchema: z.object({
+    includeAvatar: z.boolean().default(true).describe("Whether to include the avatar URL"),
+  }),
+  async execute({ includeAvatar }) {
+    const user = await getCurrentUser();
+
+    return {
+      id: user.id,
+      username: formatUsername(user),
+      globalName: user.global_name,
+      avatar: includeAvatar ? getAvatarUrl(user) : undefined,
+      bot: user.bot,
+      system: user.system,
+      mfaEnabled: user.mfa_enabled,
+      banner: user.banner,
+      accentColor: user.accent_color,
+      locale: user.locale,
+      verified: user.verified,
+      email: user.email,
+      premiumType: user.premium_type,
+      publicFlags: user.public_flags,
+    };
+  },
+});

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

@@ -0,0 +1,32 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getChannelTypeName, listChannels } from "../../lib/discord-client.ts";
+
+export default tool({
+  id: "list-channels",
+  description:
+    "List all channels in a Discord server (guild). Returns channel names, IDs, types, and basic information.",
+  inputSchema: z.object({
+    guildId: z.string().describe("The ID of the Discord server (guild) to list channels from"),
+    includeCategories: z.boolean().default(true).describe("Whether to include category channels"),
+  }),
+  async execute({ guildId, includeCategories }) {
+    const channels = await listChannels(guildId);
+
+    const filteredChannels = includeCategories
+      ? channels
+      : channels.filter((channel) => channel.type !== 4); // Filter out categories
+
+    return filteredChannels.map((channel) => ({
+      id: channel.id,
+      name: channel.name,
+      type: getChannelTypeName(channel.type),
+      typeId: channel.type,
+      topic: channel.topic,
+      nsfw: channel.nsfw,
+      position: channel.position,
+      parentId: channel.parent_id,
+      lastMessageId: channel.last_message_id,
+    }));
+  },
+});

package/dist/integrations/discord/files/ai/tools/list-guilds.ts

@@ -0,0 +1,24 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getGuildIconUrl, listGuilds } from "../../lib/discord-client.ts";
+
+export default tool({
+  id: "list-guilds",
+  description:
+    "List all Discord servers (guilds) the authenticated user is a member of. Returns server names, IDs, and basic information.",
+  inputSchema: z.object({
+    includeIcons: z.boolean().default(false).describe("Whether to include icon URLs for servers"),
+  }),
+  async execute({ includeIcons }) {
+    const guilds = await listGuilds();
+
+    return guilds.map((guild) => ({
+      id: guild.id,
+      name: guild.name,
+      owner: guild.owner,
+      icon: includeIcons ? getGuildIconUrl(guild) : undefined,
+      features: guild.features,
+      permissions: guild.permissions,
+    }));
+  },
+});

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

@@ -0,0 +1,33 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatUsername, sendMessage } from "../../lib/discord-client.ts";
+
+export default tool({
+  id: "send-message",
+  description: "Send a message to a Discord channel. Returns the sent message details.",
+  inputSchema: z.object({
+    channelId: z.string().describe("The ID of the Discord channel to send the message to"),
+    content: z.string().min(1).max(2000).describe(
+      "The message content to send (1-2000 characters)",
+    ),
+    tts: z.boolean().default(false).describe(
+      "Whether this message should be sent as text-to-speech",
+    ),
+  }),
+  async execute({ channelId, content, tts }) {
+    const message = await sendMessage(channelId, content, { tts });
+
+    return {
+      id: message.id,
+      content: message.content,
+      channelId: message.channel_id,
+      timestamp: message.timestamp,
+      author: {
+        id: message.author.id,
+        username: formatUsername(message.author),
+        globalName: message.author.global_name,
+      },
+      tts: message.tts,
+    };
+  },
+});

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

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

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

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

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

@@ -0,0 +1,273 @@
+import { getAccessToken } from "./token-store.ts";
+
+const DISCORD_API_VERSION = "v10";
+const DISCORD_BASE_URL = `https://discord.com/api/${DISCORD_API_VERSION}`;
+
+interface DiscordUser {
+  id: string;
+  username: string;
+  discriminator: string;
+  global_name?: string | null;
+  avatar?: string | null;
+  bot?: boolean;
+  system?: boolean;
+  mfa_enabled?: boolean;
+  banner?: string | null;
+  accent_color?: number | null;
+  locale?: string;
+  verified?: boolean;
+  email?: string | null;
+  flags?: number;
+  premium_type?: number;
+  public_flags?: number;
+}
+
+interface DiscordGuild {
+  id: string;
+  name: string;
+  icon?: string | null;
+  owner?: boolean;
+  permissions?: string;
+  features: string[];
+}
+
+interface DiscordChannel {
+  id: string;
+  type: number;
+  guild_id?: string;
+  position?: number;
+  name?: string;
+  topic?: string | null;
+  nsfw?: boolean;
+  last_message_id?: string | null;
+  bitrate?: number;
+  user_limit?: number;
+  rate_limit_per_user?: number;
+  recipients?: DiscordUser[];
+  icon?: string | null;
+  owner_id?: string;
+  application_id?: string;
+  parent_id?: string | null;
+  last_pin_timestamp?: string | null;
+  rtc_region?: string | null;
+  video_quality_mode?: number;
+  message_count?: number;
+  member_count?: number;
+  flags?: number;
+}
+
+interface DiscordMessage {
+  id: string;
+  channel_id: string;
+  author: DiscordUser;
+  content: string;
+  timestamp: string;
+  edited_timestamp?: string | null;
+  tts: boolean;
+  mention_everyone: boolean;
+  mentions: DiscordUser[];
+  mention_roles: string[];
+  attachments: Array<{
+    id: string;
+    filename: string;
+    size: number;
+    url: string;
+    proxy_url: string;
+    height?: number | null;
+    width?: number | null;
+    content_type?: string;
+  }>;
+  embeds: unknown[];
+  reactions?: Array<{
+    count: number;
+    me: boolean;
+    emoji: {
+      id: string | null;
+      name: string | null;
+    };
+  }>;
+  pinned: boolean;
+  type: number;
+}
+
+interface DiscordGuildMember {
+  user?: DiscordUser;
+  nick?: string | null;
+  avatar?: string | null;
+  roles: string[];
+  joined_at: string;
+  premium_since?: string | null;
+  deaf: boolean;
+  mute: boolean;
+  flags: number;
+  pending?: boolean;
+  permissions?: string;
+  communication_disabled_until?: string | null;
+}
+
+async function discordFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Discord. Please connect your account.");
+  }
+
+  const response = await fetch(`${DISCORD_BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Discord API error: ${response.status} ${error.message || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export function getCurrentUser(): Promise<DiscordUser> {
+  return discordFetch<DiscordUser>("/users/@me");
+}
+
+export function listGuilds(): Promise<DiscordGuild[]> {
+  return discordFetch<DiscordGuild[]>("/users/@me/guilds");
+}
+
+export function getGuild(guildId: string): Promise<DiscordGuild> {
+  return discordFetch<DiscordGuild>(`/guilds/${guildId}`);
+}
+
+export function listChannels(guildId: string): Promise<DiscordChannel[]> {
+  return discordFetch<DiscordChannel[]>(`/guilds/${guildId}/channels`);
+}
+
+export function getChannel(channelId: string): Promise<DiscordChannel> {
+  return discordFetch<DiscordChannel>(`/channels/${channelId}`);
+}
+
+export function getMessages(
+  channelId: string,
+  options?: {
+    limit?: number;
+    before?: string;
+    after?: string;
+    around?: string;
+  },
+): Promise<DiscordMessage[]> {
+  const params = new URLSearchParams();
+
+  if (options?.limit) {
+    params.set("limit", Math.min(options.limit, 100).toString());
+  }
+  if (options?.before) {
+    params.set("before", options.before);
+  }
+  if (options?.after) {
+    params.set("after", options.after);
+  }
+  if (options?.around) {
+    params.set("around", options.around);
+  }
+
+  const query = params.toString();
+  const endpoint = `/channels/${channelId}/messages${query ? `?${query}` : ""}`;
+
+  return discordFetch<DiscordMessage[]>(endpoint);
+}
+
+export function sendMessage(
+  channelId: string,
+  content: string,
+  options?: {
+    tts?: boolean;
+    embeds?: unknown[];
+  },
+): Promise<DiscordMessage> {
+  const body: Record<string, unknown> = { content };
+
+  if (options?.tts !== undefined) {
+    body.tts = options.tts;
+  }
+  if (options?.embeds) {
+    body.embeds = options.embeds;
+  }
+
+  return discordFetch<DiscordMessage>(`/channels/${channelId}/messages`, {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+}
+
+export function getGuildMembers(
+  guildId: string,
+  options?: {
+    limit?: number;
+    after?: string;
+  },
+): Promise<DiscordGuildMember[]> {
+  const params = new URLSearchParams();
+
+  if (options?.limit) {
+    params.set("limit", Math.min(options.limit, 1000).toString());
+  }
+  if (options?.after) {
+    params.set("after", options.after);
+  }
+
+  const query = params.toString();
+  const endpoint = `/guilds/${guildId}/members${query ? `?${query}` : ""}`;
+
+  return discordFetch<DiscordGuildMember[]>(endpoint);
+}
+
+// Helper to format username with discriminator
+export function formatUsername(user: DiscordUser): string {
+  if (user.discriminator === "0") {
+    // New username system without discriminator
+    return user.username;
+  }
+  return `${user.username}#${user.discriminator}`;
+}
+
+// Helper to get user avatar URL
+export function getAvatarUrl(user: DiscordUser, size: number = 128): string | null {
+  if (!user.avatar) return null;
+
+  const extension = user.avatar.startsWith("a_") ? "gif" : "png";
+  return `https://cdn.discordapp.com/avatars/${user.id}/${user.avatar}.${extension}?size=${size}`;
+}
+
+// Helper to get guild icon URL
+export function getGuildIconUrl(guild: DiscordGuild, size: number = 128): string | null {
+  if (!guild.icon) return null;
+
+  const extension = guild.icon.startsWith("a_") ? "gif" : "png";
+  return `https://cdn.discordapp.com/icons/${guild.id}/${guild.icon}.${extension}?size=${size}`;
+}
+
+// Helper to get channel type name
+export function getChannelTypeName(type: number): string {
+  const types: Record<number, string> = {
+    0: "Text",
+    1: "DM",
+    2: "Voice",
+    3: "Group DM",
+    4: "Category",
+    5: "Announcement",
+    10: "Announcement Thread",
+    11: "Public Thread",
+    12: "Private Thread",
+    13: "Stage Voice",
+    14: "Directory",
+    15: "Forum",
+  };
+  return types[type] || "Unknown";
+}

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

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