veryfront 0.0.49 → 0.0.50

package/dist/integrations/twitter/files/ai/tools/get-timeline.ts

@@ -0,0 +1,59 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createTwitterClient } from "../../lib/twitter-client.ts";
+
+export default tool({
+  id: "get-timeline",
+  description: "Get the authenticated user's home timeline (tweets from followed accounts)",
+  inputSchema: z.object({
+    maxResults: z
+      .number()
+      .min(1)
+      .max(100)
+      .optional()
+      .describe("Maximum number of tweets to return (default: 10)"),
+  }),
+  execute: async ({ maxResults }, context) => {
+    // Default to "current-user" for development; in production, always pass userId from session
+    const userId = (context?.userId as string | undefined) || "current-user";
+
+    try {
+      const twitter = createTwitterClient(userId);
+      const tweets = await twitter.getTimeline({
+        maxResults: maxResults || 10,
+      });
+
+      if (!tweets || tweets.length === 0) {
+        return {
+          success: true,
+          tweets: [],
+          count: 0,
+          message: "No tweets found in your timeline.",
+        };
+      }
+
+      return {
+        success: true,
+        tweets: tweets.map((tweet) => ({
+          id: tweet.id,
+          text: tweet.text,
+          author_id: tweet.author_id,
+          created_at: tweet.created_at,
+          metrics: tweet.public_metrics,
+          hashtags: tweet.entities?.hashtags?.map((h) => h.tag),
+          mentions: tweet.entities?.mentions?.map((m) => m.username),
+        })),
+        count: tweets.length,
+        message: `Retrieved ${tweets.length} tweets from your timeline.`,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Twitter not connected. Please connect your Twitter account.",
+          connectUrl: "/api/auth/twitter",
+        };
+      }
+      throw error;
+    }
+  },
+});

package/dist/integrations/twitter/files/ai/tools/post-tweet.ts

@@ -0,0 +1,49 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createTwitterClient } from "../../lib/twitter-client.ts";
+
+export default tool({
+  id: "post-tweet",
+  description: "Post a new tweet to Twitter/X. Maximum length is 280 characters.",
+  inputSchema: z.object({
+    text: z
+      .string()
+      .min(1)
+      .max(280)
+      .describe("Tweet text content (max 280 characters)"),
+  }),
+  execute: async ({ text }, context) => {
+    // Default to "current-user" for development; in production, always pass userId from session
+    const userId = (context?.userId as string | undefined) || "current-user";
+
+    // Validate tweet length
+    if (text.length > 280) {
+      return {
+        error: "Tweet text exceeds 280 character limit",
+        length: text.length,
+        maxLength: 280,
+      };
+    }
+
+    try {
+      const twitter = createTwitterClient(userId);
+      const result = await twitter.postTweet(text);
+
+      return {
+        success: true,
+        tweetId: result.id,
+        text: result.text,
+        message: "Tweet posted successfully!",
+        url: `https://twitter.com/i/web/status/${result.id}`,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Twitter not connected. Please connect your Twitter account.",
+          connectUrl: "/api/auth/twitter",
+        };
+      }
+      throw error;
+    }
+  },
+});

package/dist/integrations/twitter/files/ai/tools/search-tweets.ts

@@ -0,0 +1,71 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createTwitterClient } from "../../lib/twitter-client.ts";
+
+export default tool({
+  id: "search-tweets",
+  description:
+    "Search recent tweets on Twitter/X. Returns up to 10 recent tweets matching the query.",
+  inputSchema: z.object({
+    query: z
+      .string()
+      .min(1)
+      .describe(
+        "Search query (supports Twitter search operators like 'from:', 'to:', '#hashtag', etc.)",
+      ),
+    maxResults: z
+      .number()
+      .min(1)
+      .max(100)
+      .optional()
+      .describe("Maximum number of tweets to return (default: 10)"),
+    sortOrder: z
+      .enum(["recency", "relevancy"])
+      .optional()
+      .describe("Sort order: 'recency' (default) or 'relevancy'"),
+  }),
+  execute: async ({ query, maxResults, sortOrder }, context) => {
+    // Default to "current-user" for development; in production, always pass userId from session
+    const userId = (context?.userId as string | undefined) || "current-user";
+
+    try {
+      const twitter = createTwitterClient(userId);
+      const result = await twitter.searchTweets(query, {
+        maxResults: maxResults || 10,
+        sortOrder: sortOrder || "recency",
+      });
+
+      if (!result.data || result.data.length === 0) {
+        return {
+          success: true,
+          tweets: [],
+          count: 0,
+          message: `No tweets found matching query: "${query}"`,
+        };
+      }
+
+      return {
+        success: true,
+        tweets: result.data.map((tweet) => ({
+          id: tweet.id,
+          text: tweet.text,
+          author_id: tweet.author_id,
+          created_at: tweet.created_at,
+          metrics: tweet.public_metrics,
+          hashtags: tweet.entities?.hashtags?.map((h) => h.tag),
+          mentions: tweet.entities?.mentions?.map((m) => m.username),
+        })),
+        count: result.meta.result_count,
+        message: `Found ${result.meta.result_count} tweets matching query: "${query}"`,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Twitter not connected. Please connect your Twitter account.",
+          connectUrl: "/api/auth/twitter",
+        };
+      }
+      throw error;
+    }
+  },
+});

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

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

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

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

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

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

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

@@ -0,0 +1,236 @@
+/**
+ * Twitter API Client
+ *
+ * Provides a type-safe interface to Twitter API v2 operations.
+ */
+
+import { tokenStore as _tokenStore } from "./token-store.ts";
+import { getValidToken } from "./oauth.ts";
+
+// Helper for Cross-Platform environment access
+function getEnv(key: string): string | undefined {
+  // @ts-ignore - Deno global
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore - Deno global
+    return Deno.env.get(key);
+  } // @ts-ignore - process global
+  else if (typeof process !== "undefined" && process.env) {
+    // @ts-ignore - process global
+    return process.env[key];
+  }
+  return undefined;
+}
+
+const TWITTER_API_BASE = "https://api.twitter.com/2";
+
+export interface TwitterUser {
+  id: string;
+  name: string;
+  username: string;
+  created_at?: string;
+  description?: string;
+  location?: string;
+  profile_image_url?: string;
+  public_metrics?: {
+    followers_count: number;
+    following_count: number;
+    tweet_count: number;
+    listed_count: number;
+  };
+  verified?: boolean;
+}
+
+export interface Tweet {
+  id: string;
+  text: string;
+  author_id?: string;
+  created_at?: string;
+  public_metrics?: {
+    retweet_count: number;
+    reply_count: number;
+    like_count: number;
+    quote_count: number;
+  };
+  referenced_tweets?: Array<{
+    type: string;
+    id: string;
+  }>;
+  entities?: {
+    hashtags?: Array<{ tag: string }>;
+    mentions?: Array<{ username: string; id: string }>;
+    urls?: Array<{ url: string; expanded_url: string }>;
+  };
+}
+
+export interface SearchResult {
+  data: Tweet[];
+  meta: {
+    newest_id?: string;
+    oldest_id?: string;
+    result_count: number;
+    next_token?: string;
+  };
+}
+
+/**
+ * Twitter OAuth provider configuration
+ */
+export const twitterOAuthProvider = {
+  name: "twitter",
+  authorizationUrl: "https://twitter.com/i/oauth2/authorize",
+  tokenUrl: "https://api.twitter.com/2/oauth2/token",
+  clientId: getEnv("TWITTER_CLIENT_ID") || "",
+  clientSecret: getEnv("TWITTER_CLIENT_SECRET") || "",
+  scopes: [
+    "tweet.read",
+    "tweet.write",
+    "users.read",
+    "follows.read",
+    "offline.access",
+  ],
+  callbackPath: "/api/auth/twitter/callback",
+  usePKCE: true,
+};
+
+/**
+ * Create a Twitter client for a specific user
+ */
+export function createTwitterClient(userId: string) {
+  const getAccessToken = async (): Promise<string> => {
+    const token = await getValidToken(twitterOAuthProvider, userId, "twitter");
+    if (!token) {
+      throw new Error("Twitter not connected. Please connect your Twitter account first.");
+    }
+    return token;
+  };
+
+  const twitterFetch = async <T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> => {
+    const accessToken = await getAccessToken();
+
+    const response = await fetch(`${TWITTER_API_BASE}${endpoint}`, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ detail: response.statusText }));
+      throw new Error(`Twitter API error: ${error.detail || error.title || response.statusText}`);
+    }
+
+    return response.json();
+  };
+
+  return {
+    /**
+     * Get authenticated user information
+     */
+    getMe: async (): Promise<TwitterUser> => {
+      const result = await twitterFetch<{ data: TwitterUser }>(
+        "/users/me?user.fields=created_at,description,location,profile_image_url,public_metrics,verified",
+      );
+      return result.data;
+    },
+
+    /**
+     * Get user by ID
+     */
+    getUserById: async (userId: string): Promise<TwitterUser> => {
+      const result = await twitterFetch<{ data: TwitterUser }>(
+        `/users/${userId}?user.fields=created_at,description,location,profile_image_url,public_metrics,verified`,
+      );
+      return result.data;
+    },
+
+    /**
+     * Get user's tweets
+     */
+    getTweets: async (
+      userId: string,
+      options: { maxResults?: number; excludeReplies?: boolean } = {},
+    ): Promise<Tweet[]> => {
+      const params = new URLSearchParams({
+        "max_results": String(options.maxResults || 10),
+        "tweet.fields": "created_at,public_metrics,referenced_tweets,entities",
+      });
+
+      if (options.excludeReplies) {
+        params.set("exclude", "replies");
+      }
+
+      const result = await twitterFetch<{ data: Tweet[] }>(
+        `/users/${userId}/tweets?${params.toString()}`,
+      );
+      return result.data || [];
+    },
+
+    /**
+     * Get single tweet by ID
+     */
+    getTweet: async (tweetId: string): Promise<Tweet> => {
+      const result = await twitterFetch<{ data: Tweet }>(
+        `/tweets/${tweetId}?tweet.fields=created_at,public_metrics,referenced_tweets,entities,author_id`,
+      );
+      return result.data;
+    },
+
+    /**
+     * Post a new tweet
+     */
+    postTweet: async (text: string): Promise<{ id: string; text: string }> => {
+      const result = await twitterFetch<{ data: { id: string; text: string } }>(
+        "/tweets",
+        {
+          method: "POST",
+          body: JSON.stringify({ text }),
+        },
+      );
+      return result.data;
+    },
+
+    /**
+     * Search recent tweets
+     */
+    searchTweets: (
+      query: string,
+      options: { maxResults?: number; sortOrder?: "recency" | "relevancy" } = {},
+    ): Promise<SearchResult> => {
+      const params = new URLSearchParams({
+        query,
+        "max_results": String(options.maxResults || 10),
+        "tweet.fields": "created_at,public_metrics,referenced_tweets,entities,author_id",
+        "sort_order": options.sortOrder || "recency",
+      });
+
+      return twitterFetch<SearchResult>(
+        `/tweets/search/recent?${params.toString()}`,
+      );
+    },
+
+    /**
+     * Get home timeline (reverse chronological tweets from followed accounts)
+     */
+    getTimeline: async (options: { maxResults?: number } = {}): Promise<Tweet[]> => {
+      const me = await twitterFetch<{ data: TwitterUser }>("/users/me");
+      const userId = me.data.id;
+
+      const params = new URLSearchParams({
+        "max_results": String(options.maxResults || 10),
+        "tweet.fields": "created_at,public_metrics,referenced_tweets,entities,author_id",
+      });
+
+      const result = await twitterFetch<{ data: Tweet[] }>(
+        `/users/${userId}/timelines/reverse_chronological?${params.toString()}`,
+      );
+      return result.data || [];
+    },
+  };
+}
+
+export type TwitterClient = ReturnType<typeof createTwitterClient>;

package/dist/integrations/webex/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "webex",
+  "displayName": "Webex",
+  "icon": "webex.svg",
+  "description": "Manage meetings, rooms, and messages in Webex",
+  "auth": {
+    "type": "oauth2",
+    "provider": "webex",
+    "authorizationUrl": "https://webexapis.com/v1/authorize",
+    "tokenUrl": "https://webexapis.com/v1/access_token",
+    "scopes": ["spark:all", "spark:kms"],
+    "callbackPath": "/api/auth/webex/callback",
+    "requiredApis": [
+      {
+        "name": "Webex Developer Portal",
+        "enableUrl": "https://developer.webex.com/my-apps"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "WEBEX_CLIENT_ID",
+      "description": "Webex OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developer.webex.com/docs/integrations"
+    },
+    {
+      "name": "WEBEX_CLIENT_SECRET",
+      "description": "Webex OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developer.webex.com/docs/integrations"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-meetings",
+      "name": "List Meetings",
+      "description": "List scheduled Webex meetings",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-meeting",
+      "name": "Get Meeting",
+      "description": "Get details of a specific meeting",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-meeting",
+      "name": "Create Meeting",
+      "description": "Schedule a new Webex meeting",
+      "requiresWrite": true
+    },
+    {
+      "id": "list-rooms",
+      "name": "List Rooms",
+      "description": "List Webex spaces/rooms",
+      "requiresWrite": false
+    },
+    {
+      "id": "send-message",
+      "name": "Send Message",
+      "description": "Send a message to a Webex room",
+      "requiresWrite": true
+    }
+  ],
+  "prompts": [
+    {
+      "id": "my-meetings",
+      "title": "Show my meetings",
+      "prompt": "List all my upcoming Webex meetings with their times and join links.",
+      "category": "productivity",
+      "icon": "video"
+    },
+    {
+      "id": "create-meeting",
+      "title": "Schedule a meeting",
+      "prompt": "Create a new Webex meeting with a title, start time, duration, and agenda.",
+      "category": "productivity",
+      "icon": "plus"
+    }
+  ],
+  "suggestedWith": ["calendar", "slack", "teams"]
+}

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

@@ -0,0 +1,4 @@
+# Webex OAuth Configuration
+# Get your credentials from https://developer.webex.com/my-apps
+WEBEX_CLIENT_ID=your-client-id
+WEBEX_CLIENT_SECRET=your-client-secret

package/dist/integrations/webex/files/ai/tools/create-meeting.ts

@@ -0,0 +1,69 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createMeeting } from "../../lib/webex-client.ts";
+
+export default tool({
+  id: "create-meeting",
+  description: "Schedule a new Webex meeting with specified details.",
+  inputSchema: z.object({
+    title: z.string().describe("Title of the meeting"),
+    agenda: z.string().optional().describe("Meeting agenda or description"),
+    start: z.string().describe(
+      "Start date and time in ISO 8601 format (e.g., 2024-01-15T14:00:00Z)",
+    ),
+    end: z.string().describe(
+      "End date and time in ISO 8601 format (e.g., 2024-01-15T15:00:00Z)",
+    ),
+    timezone: z.string().default("UTC").describe(
+      "Timezone for the meeting (e.g., America/New_York, Europe/London)",
+    ),
+    enabledAutoRecordMeeting: z.boolean().default(false).describe(
+      "Automatically record the meeting",
+    ),
+    allowAnyUserToBeCoHost: z.boolean().default(false).describe(
+      "Allow any user to be a co-host",
+    ),
+    invitees: z.array(
+      z.object({
+        email: z.string().email().describe("Email address of the invitee"),
+        displayName: z.string().optional().describe("Display name of the invitee"),
+        coHost: z.boolean().default(false).describe("Make this invitee a co-host"),
+      }),
+    ).optional().describe("List of invitees to the meeting"),
+  }),
+  async execute({
+    title,
+    agenda,
+    start,
+    end,
+    timezone,
+    enabledAutoRecordMeeting,
+    allowAnyUserToBeCoHost,
+    invitees,
+  }) {
+    const meeting = await createMeeting({
+      title,
+      agenda,
+      start,
+      end,
+      timezone,
+      enabledAutoRecordMeeting,
+      allowAnyUserToBeCoHost,
+      invitees,
+    });
+
+    return {
+      id: meeting.id,
+      title: meeting.title,
+      agenda: meeting.agenda,
+      start: meeting.start,
+      end: meeting.end,
+      timezone: meeting.timezone,
+      hostEmail: meeting.hostEmail,
+      hostDisplayName: meeting.hostDisplayName,
+      webLink: meeting.webLink,
+      meetingNumber: meeting.meetingNumber,
+      message: `Meeting "${meeting.title}" created successfully. Join URL: ${meeting.webLink}`,
+    };
+  },
+});

package/dist/integrations/webex/files/ai/tools/get-meeting.ts

@@ -0,0 +1,31 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getMeeting } from "../../lib/webex-client.ts";
+
+export default tool({
+  id: "get-meeting",
+  description: "Get detailed information about a specific Webex meeting by its ID.",
+  inputSchema: z.object({
+    meetingId: z.string().describe("The unique ID of the meeting"),
+  }),
+  async execute({ meetingId }) {
+    const meeting = await getMeeting(meetingId);
+
+    return {
+      id: meeting.id,
+      title: meeting.title,
+      agenda: meeting.agenda,
+      start: meeting.start,
+      end: meeting.end,
+      timezone: meeting.timezone,
+      hostEmail: meeting.hostEmail,
+      hostDisplayName: meeting.hostDisplayName,
+      webLink: meeting.webLink,
+      sipAddress: meeting.sipAddress,
+      meetingNumber: meeting.meetingNumber,
+      state: meeting.state,
+      enabledAutoRecordMeeting: meeting.enabledAutoRecordMeeting,
+      allowAnyUserToBeCoHost: meeting.allowAnyUserToBeCoHost,
+    };
+  },
+});

package/dist/integrations/webex/files/ai/tools/list-meetings.ts

@@ -0,0 +1,44 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listMeetings } from "../../lib/webex-client.ts";
+
+export default tool({
+  id: "list-meetings",
+  description:
+    "List scheduled Webex meetings. Can filter by date range and meeting state.",
+  inputSchema: z.object({
+    max: z.number().min(1).max(100).default(20).describe(
+      "Maximum number of meetings to return",
+    ),
+    from: z.string().optional().describe(
+      "Start date in ISO 8601 format (e.g., 2024-01-01T00:00:00Z)",
+    ),
+    to: z.string().optional().describe(
+      "End date in ISO 8601 format (e.g., 2024-12-31T23:59:59Z)",
+    ),
+    state: z.enum(["active", "scheduled", "ended", "missed", "inProgress"]).optional()
+      .describe("Filter by meeting state"),
+  }),
+  async execute({ max, from, to, state }) {
+    const meetings = await listMeetings({
+      max,
+      from,
+      to,
+      state,
+    });
+
+    return meetings.map((meeting) => ({
+      id: meeting.id,
+      title: meeting.title,
+      agenda: meeting.agenda,
+      start: meeting.start,
+      end: meeting.end,
+      timezone: meeting.timezone,
+      hostEmail: meeting.hostEmail,
+      hostDisplayName: meeting.hostDisplayName,
+      webLink: meeting.webLink,
+      meetingNumber: meeting.meetingNumber,
+      state: meeting.state,
+    }));
+  },
+});